我有一段代码正在初始化一个记录器,如下所示。
logger = logging.getLogger()
hdlr = logging.FileHandler('logfile.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.DEBUG)
不幸的是这个代码被多次调用,有什么方法可以检查处理程序是否已经存在 - 我更愿意实现它而不必使用Singleton。
编辑:对不起,忘了提到这是在python 2.5上 - 干杯,理查德答案 0 :(得分:27)
作为@offbyone注释,可以将冗余处理程序添加到记录器的同一实例中。 python docs for logging说 -
"对具有相同名称的getLogger()的多次调用将返回a 引用相同的记录器对象。"
所以我们不必担心将实现变成单例,就像现在一样。
不幸的是,对于与记录器的同一实例关联的处理程序,不正确也是如此。 可以是附加的重复处理程序。
实施例 -
复制此代码并将其保存在main.py
中import logging
print 'inside main.py',
print '-'*50
def logger():
print 'initializing logger....'
logPath = '.'
fileName = 'temp'
# configure log formatter
logFormatter = logging.Formatter("%(asctime)s [%(filename)s] [%(funcName)s] [%(levelname)s] [%(lineno)d] %(message)s")
# configure file handler
fileHandler = logging.FileHandler("{0}/{1}.log".format(logPath, fileName))
fileHandler.setFormatter(logFormatter)
# configure stream handler
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(logFormatter)
# get the logger instance
logger = logging.getLogger(__name__)
# set the logging level
logger.setLevel(logging.DEBUG)
print 'adding handlers- '
#if not len(logger.handlers):
logger.addHandler(fileHandler)
logger.addHandler(consoleHandler)
print 'logger initialized....\n'
print 'associated handlers - ', len(logger.handlers)
for handler in logger.handlers:
print handler
print
return logger
main_logger = logger()
main_logger.info('utilizing main.py logger.')
print 'exiting main.py',
print '-'*50
以及sub.py中的以下代码
print 'inside sub.py',
print '-'*50
print 'importing main.py'
import main
print 'imported main.py'
import logging
print 'getting logger instance in sub'
sub_logger = main.logger()
print 'got logger instance in sub'
sub_logger.info("utilizing sub_logger")
print 'exiting sub.py',
print '-'*50
运行sub.py
narayan@y510p:~/code/so$ python sub.py
inside sub.py --------------------------------------------------
importing main.py
inside main.py --------------------------------------------------
initializing logger....
adding handlers-
logger initialized....
associated handlers - 2
<logging.FileHandler object at 0x7f7158740c90>
<logging.StreamHandler object at 0x7f7158710b10>
2015-08-04 07:41:01,824 [main.py] [<module>] [INFO] [41] utilizing main.py logger.
exiting main.py --------------------------------------------------
imported main.py
getting logger instance in sub
initializing logger....
adding handlers-
logger initialized....
associated handlers - 4 # <===== 4 handlers (duplicates added)
<logging.FileHandler object at 0x7f7158740c90>
<logging.StreamHandler object at 0x7f7158710b10>
<logging.FileHandler object at 0x7f7158710bd0>
<logging.StreamHandler object at 0x7f7158710c10>
got logger instance in sub
2015-08-04 07:41:01,824 [sub.py] [<module>] [INFO] [10] utilizing sub_logger
2015-08-04 07:41:01,824 [sub.py] [<module>] [INFO] [10] utilizing sub_logger
exiting sub.py --------------------------------------------------
因此,多次调用返回同一记录器的方法会添加重复的处理程序。
现在,针对您的问题 -
有什么方法可以检查处理程序是否已经存在
是的,有 -
logger.handlers
返回与给定logger
相关联的所有处理程序的列表。
在将处理程序添加到记录器的实例之前,请确保不要添加重复的处理程序
在main.py中,只需取消注释显示if not len(logger.handlers):
的行并正确缩进以下两行 -
if not len(logger.handlers):
logger.addHandler(fileHandler)
logger.addHandler(consoleHandler)
现在再次运行sub.py
narayan@y510p:~/code/so$ python sub.py
inside sub.py --------------------------------------------------
importing main.py
inside main.py --------------------------------------------------
initializing logger....
adding handlers-
logger initialized....
associated handlers - 2
<logging.FileHandler object at 0x7fd67a891c90>
<logging.StreamHandler object at 0x7fd67a862b10>
2015-08-04 08:14:45,620 [main.py] [<module>] [INFO] [41] utilizing main.py logger.
exiting main.py --------------------------------------------------
imported main.py
getting logger instance in sub
initializing logger....
adding handlers-
logger initialized....
associated handlers - 2 # <===== Still 2 handlers (no duplicates)
<logging.FileHandler object at 0x7fd67a891c90>
<logging.StreamHandler object at 0x7fd67a862b10>
got logger instance in sub
2015-08-04 08:14:45,620 [sub.py] [<module>] [INFO] [10] utilizing sub_logger
exiting sub.py --------------------------------------------------
此外,如果要限制要添加到记录器实例的处理程序类型,可以执行以下操作 -
print 'adding handlers- '
# allows to add only one instance of file handler and stream handler
if len(logger.handlers) > 0:
print 'making sure we do not add duplicate handlers'
for handler in logger.handlers:
# add the handlers to the logger
# makes sure no duplicate handlers are added
if not isinstance(handler, logging.FileHandler) and not isinstance(handler, logging.StreamHandler):
logger.addHandler(fileHandler)
print 'added file handler'
logger.addHandler(consoleHandler)
print 'added stream handler'
else:
logger.addHandler(fileHandler)
logger.addHandler(consoleHandler)
print 'added handlers for the first time'
希望这有帮助!
编辑:
不幸的是,对于相关的处理程序,不正确也是如此 使用相同的记录器实例。 可以重复 处理程序附加。
事实证明,上述陈述并非完全正确。
假设我们在主模块中创建并配置了一个名为&#39; main_logger&#39; 的记录器(它只是配置记录器,不会返回任何内容) )。
# get the logger instance
logger = logging.getLogger("main_logger")
# configuration follows
...
现在在子模块中,如果我们按照命名层次结构&#39; main_logger.sub_module_logger&#39; 创建子记录器,我们不需要在子模块。只需在命名层次结构后创建记录器就足够了。
# get the logger instance
logger = logging.getLogger("main_logger.sub_module_logger")
# no configuration needed
# it inherits the configuration from the parent logger
...
它也不会添加重复的处理程序。
答案 1 :(得分:15)
如果处理程序已经存在,logger.addHandler()将不会添加处理程序。要检查处理程序是否已经存在,您可以检查logger.handlers列表:
logger = logging.getLogger()
hdlr = logging.FileHandler('logfile.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.DEBUG)
print logger.handlers
# [<logging.FileHandler object at 0x14542d0>]
logger.addHandler(hdlr)
print logger.handlers
# [<logging.FileHandler object at 0x14542d0>]
除此之外,如果您有一个或在您的包的__init__.py
文件中,我建议将此代码放在main()函数中,以便每次都不必调用它。我还建议您使用命名记录器,不要使用根记录器。像这样:
logger = logging.getLogger(__name__)
...
希望这有用:)
答案 2 :(得分:4)
您还可以检查处理程序列表是否为空。这是我结束的解决方案:
def setup_logging(self, logfile):
self._logger = logging.getLogger('TestSuite')
self._logger.setLevel(logging.INFO)
host = socket.gethostname().split('.')[0]
if self._logger.handlers == []:
fh = logging.handlers.RotatingFileHandler(logfile,
maxBytes=10*1024*1024,
backupCount=5)
strfmt = "%" + "(asctime)s [%s] " % host + "%" + "(message)s"
fmt = logging.Formatter(strfmt, datefmt="%Y.%m%d %H:%M:%S")
fh.setFormatter(fmt)
self._logger.addHandler(fh)
self._logger.info('-' * (55 - len(host)))
我看到处理程序多次添加,因此每条日志消息都被多次写入日志文件,这就修复了它。
答案 3 :(得分:2)
如果您熟悉AWS Lambda,那么您可能已经知道在某些情况下,处理程序已预先配置[1]。假设logger.handlers
不为空,那还不够。我建议在记录器实例上设置一个属性,如下所示:
def init_logger(logger):
if hasattr(logger, 'initialized'):
return logger # No need for addHandler
else:
setattr(logger, 'initialized', True)
# Initialize the logger
# ...
答案 4 :(得分:1)
尝试检查是否已设置logger
。例如,如果此代码位于函数内:
logger = None
def init_logger():
global logger
if logger is not None:
#logger has already been initialized
return
logger = logging.getLogger()
hdlr = logging.FileHandler('logfile.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
logger.setLevel(logging.DEBUG)