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)

不幸的是这个代码被多次调用，有什么方法可以检查处理程序是否已经存在 - 我更愿意实现它而不必使用Singleton。

编辑：对不起，忘了提到这是在python 2.5上 - 干杯，理查德

Answer 1

作为@offbyone注释，可以将冗余处理程序添加到记录器的同一实例中。 python docs for logging说 -

＆＃34;对具有相同名称的getLogger（）的多次调用将返回a 引用相同的记录器对象。＆＃34;

所以我们不必担心将实现变成单例，就像现在一样。

不幸的是，对于与记录器的同一实例关联的处理程序，不正确也是如此。可以是附加的重复处理程序。

实施例 -

复制此代码并将其保存在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
...

它也不会添加重复的处理程序。

参考 - Using logging in multiple modules

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

除此之外，如果您有一个或在您的包的__init__.py文件中，我建议将此代码放在main（）函数中，以便每次都不必调用它。我还建议您使用命名记录器，不要使用根记录器。像这样：

logger = logging.getLogger(__name__)
...

希望这有用：）

Answer 3

您还可以检查处理程序列表是否为空。这是我结束的解决方案：

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 4

如果您熟悉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
    # ...

[1] Using python Logging with AWS Lambda

Answer 5

尝试检查是否已设置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)

python日志记录确保只添加一次处理程序

5 个答案: