python logging 确保处理器只添加一次

Question

我有一段代码，下面是用来初始化一个日志记录器的。

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)

不幸的是，这段代码被调用了很多次，有没有办法检查一下这个处理器是否已经存在？我希望能在不使用单例模式的情况下实现这个功能。

补充说明：抱歉，忘了提这是在 Python 2.5 上运行的 - 谢谢，理查德

Answer 1

你也可以直接检查一下处理程序列表是否为空。下面是我最终找到的解决方案：

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)))

我发现处理程序被添加了多次，所以每条日志信息都被写入日志文件好几次，这个方法解决了这个问题。

Answer 2

好吧，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>]

另外，我建议把这段代码放在你的 main() 函数里（如果你有的话），或者放在你包的 __init__.py 文件中，这样就不用每次都调用它了。我还建议你使用一个命名的日志记录器，而不是使用根日志记录器。可以像这样做：

logger = logging.getLogger(__name__)
...

希望这些对你有帮助 :)

Answer 3

正如@offbyone所说，我们可以给同一个日志记录器的实例添加多个冗余的处理器。Python的日志记录文档提到：

“多次调用getLogger()并使用相同的名称会返回同一个日志记录器对象的引用。”

所以我们不需要担心实现成单例模式，因为它本身就是单例的。

但不幸的是，关于与同一日志记录器实例关联的处理器，情况并非如此。可能会有重复的处理器被附加。

举个例子：

1. 把这段代码复制并保存为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
   

2. 把下面的代码保存为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
   

3. 运行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'

希望这对你有帮助！

编辑：

不幸的是，关于与同一日志记录器实例关联的处理器，情况并非如此。可能会有重复的处理器被附加。

事实证明，上面的说法并不完全正确。

假设我们在主模块中创建并配置了一个名为'main_logger'的日志记录器（它只是配置日志记录器，不返回任何东西）。

# get the logger instance
logger = logging.getLogger("main_logger")
# configuration follows
...

现在在一个子模块中，如果我们按照命名层次结构创建一个子日志记录器'main_logger.sub_module_logger'，那么在子模块中就不需要再配置它。只需按照命名层次结构创建日志记录器就足够了。

# get the logger instance
logger = logging.getLogger("main_logger.sub_module_logger")
# no configuration needed
# it inherits the configuration from the parent logger
...

而且这样也不会添加重复的处理器。

参考资料：在多个模块中使用日志记录