Python 在不同的日志级别记录到多个处理程序？

Posted 2023-03-04

【中文标题】Python 在不同的日志级别记录到多个处理程序？

【英文标题】：Python logging to multiple handlers, at different log levels?

【发布时间】：2014-09-30 23:08:51

【问题描述】：

伙计们，

我对一个我无法正确设置的 python 日志记录配置摸不着头脑。

假设我安装了以下软件包：

mypackage/
   data/mypackage.logging.conf
   module1.py
   module2.py
   scripts/main.py

由于脚本可以交互使用或从 crontab 运行，我有以下要求：

没有打印语句，一切都通过日志记录；

使用timedRotatingFileHandler 记录日志，总是在 DEBUG 级别；

使用mailinglogger.SummarisingLogger 记录，总是在 INFO 级别；

登录到控制台，级别默认设置为 INFO 或通过命令行选项覆盖。

问题是，我可以通过命令行更改日志级别，控制台日志级别也相应更改，但其他处理程序也更改了，我不希望... :-/

在日志记录配置文件中，我不确定我是否理解根记录器级别、其他记录器级别和处理程序级别设置之间的优先级。

这里是一些示例代码。任何线索将不胜感激:-)

# mypackage/data/mypackage.logging.conf
[loggers]
root,mypackage

[handlers]
keys=consoleHandler,timedRotatingFileHandler,summarisingHandler

[formatters]
keys=simpleFormatter,consoleFormatter,mypackageFormatter

[logger_root]
#level=INFO
handlers=consoleHandler

[logger_mypackage]
#level=INFO
handlers=timedRotatingFileHandler,summarisingHandler
qualname=mypackage

[handler_consoleHandler]
class=StreamHandler
#level=INFO
formatter=consoleFormatter
args=(sys.stdout,)

[handler_timedRotatingFileHandler]
class=logging.handlers.TimedRotatingFileHandler
level=DEBUG
formatter=mypackageFormatter
args=('mypackage.log', 'M', 1, 5)

[handler_summarisingHandler]
class=mailinglogger.SummarisingLogger
level=INFO
formatter=mypackageFormatter
args=('[e-mail]', ('[e-mail]',), 'relay.somewhere.com')

---

#mypackage/scripts/main.py:
import logging
import logging.config
import os
import sys

import mypackage.module1
import mypackage.module2

logging.config.fileConfig('data/mypackage.logging.conf')
log = logging.getLogger(__name__)

if __name__ == '__main__':
    loglevel = 'INFO'
    if len(sys.argv) > 1:
        loglevel = sys.argv[1].upper()

    logging.getLogger('').setLevel(getattr(logging, loglevel))
    # or logging.getLogger('mypackage').setLevel(getattr(logging, loglevel)) ?

    mypackage.module1.do_something()
    mypackage.module2.do_something_else()

---

#mypackage/module1.py:
import logging

log = logging.getLogger(__name__)
log.addHandler(NullHandler())

def do_something():
    log.debug("some debug message from:" + __name__)
    log.info("some info message from:" + __name__)
    log.error("some error message from:" + __name__)

---

#mypackage/module2.py:
import logging

log = logging.getLogger(__name__)
log.addHandler(NullHandler())

def do_something_else():
    log.debug("some debug message from:" + __name__)
    log.info("some info message from:" + __name__)
    log.error("some error message from:" + __name__)

---

更新 1

与此同时，我发现了this answer，并以这种方式成功修改了我的代码：

#mypackage/scripts/main.py:
import logging
import logging.config
import os
import sys
import mailinglogger

import mypackage.module1
import mypackage.module2

def main():
    # get the console log level from the command-line
    loglevel = 'INFO'
    if len(sys.argv) > 1:
        loglevel = sys.argv[1].upper()

    # create formatters
    simple_formatter = logging.Formatter("%(name)s:%(levelname)s: %(message)s")
    detailed_formatter = logging.Formatter("%(asctime)s %(name)s[%(process)d]: %(levelname)s - %(message)s")

    # get a top-level "mypackage" logger,
    # set its log level to DEBUG,
    # BUT PREVENT IT from propagating messages to the root logger
    #
    log = logging.getLogger('mypackage')
    log.setLevel(logging.DEBUG)
    log.propagate = 0

    # create a console handler
    # and set its log level to the command-line option 
    # 
    console_handler = logging.StreamHandler(sys.stdout)
    console_handler.setLevel(getattr(logging, loglevel))
    console_handler.setFormatter(simple_formatter)

    # create a file handler
    # and set its log level to DEBUG
    #
    file_handler = logging.handlers.TimedRotatingFileHandler('mypackage.log', 'M', 1, 5)
    file_handler.setLevel(logging.DEBUG)
    file_handler.setFormatter(detailed_formatter)

    # create a mail handler
    # and set its log level to INFO
    #
    mail_handler = mailinglogger.SummarisingLogger(
        '[e-mail]', ('[e-mail]',), 'relay.somewhere.com')
    mail_handler.setLevel(logging.INFO)
    mail_handler.setFormatter(detailed_formatter)

    # add handlers to the "mypackage" logger
    #
    log.addHandler(console_handler)
    log.addHandler(file_handler)
    log.addHandler(mail_handler)

    # let the modules do their stuff 
    # and log to the "mypackage.module1" and "mypackage.module2" loggers
    #
    mypackage.module1.do_something()
    mypackage.module2.do_something_else()


if __name__ == '__main__':
    main()

现在，我将尝试在 logging.config 文件中翻译它...

---

更新 2

这是我找到的最好的日志记录配置和代码组合。

在 mypackage.logging.conf 文件中，“mypackage”记录器是：

仅使用文件和电子邮件处理程序进行设置； 其传播设置为 false； 其级别设置为 DEBUG； 文件和电子邮件处理程序分别设置为 INFO 和 DEBUG。

---

#mypackage/data/mypackage.logging.conf
[loggers]
keys=root,mypackage

[handlers]
keys=consoleHandler,timedRotatingFileHandler,summarisingHandler

[formatters]
keys=simpleFormatter,consoleFormatter,mypackageFormatter

[logger_root]
#level=INFO
handlers=consoleHandler

[logger_mypackage]
level=DEBUG
handlers=timedRotatingFileHandler,summarisingHandler
qualname=mypackage
propagate=0

[handler_consoleHandler]
class=StreamHandler
#level=INFO
formatter=consoleFormatter
args=(sys.stdout,)

[handler_timedRotatingFileHandler]
class=logging.handlers.TimedRotatingFileHandler
level=DEBUG
formatter=mypackageFormatter
args=('mypackage.log', 'M', 1, 5)

[handler_summarisingHandler]
class=mailinglogger.SummarisingLogger
level=INFO
formatter=mypackageFormatter
args=('[e-mail]', ('[e-mail]',), 'relay.somewhere.com')

[formatter_consoleFormatter]
format=%(levelname)s: %(message)s
datefmt=

[formatter_mypackageFormatter]
format=%(asctime)s %(name)s[%(process)d]: %(levelname)s - %(message)s
datefmt=

---

在脚本中：

日志配置被读取；

（重新）创建了一个 console_formatter；

使用命令行选项的日志级别创建控制台处理程序，然后添加到“mypackage”记录器。

---

import logging
import logging.config
import os
import sys

import mypackage.module1
import mypackage.module2

def setup_logging(loglevel):
    #
    # load logging config from file
    #
    logging.config.fileConfig('data/mypackage.logging.conf')

    # (re-)create formatter
    console_formatter = logging.Formatter("%(name)s:%(levelname)s: %(message)s")

    # create a console handler
    # and set its log level to the command-line option 
    # 
    console_handler = logging.StreamHandler(sys.stdout)
    console_handler.setFormatter(console_formatter)
    console_handler.setLevel(getattr(logging, loglevel))

    # add console handler to the pre-configured "mypackage" logger
    #
    logger = logging.getLogger('mypackage')
    logger.addHandler(console_handler)


def main():
    # get the console log level from the command-line
    loglevel = 'INFO'
    if len(sys.argv) > 1:
        loglevel = sys.argv[1].upper()

    # load logging config and setup console handler
    #
    setup_logging(loglevel)

    # log from the script to the "mypackage.scripts.main" logger
    #
    log = logging.getLogger(__name__)
    log.debug("some debug message from:" + __name__)
    log.info("some info message from:" + __name__)
    log.error("some error message from:" + __name__)

    # let the modules do their stuff 
    # and log to the "mypackage.module1" and "mypackage.module2" loggers
    #
    mypackage.module1.do_something()
    mypackage.module2.do_something_else()

if __name__== '__main__':
    main()

---

如果处理程序在从配置文件加载时按名称“可寻址”，事情会更简单。

然后，我们可以在配置文件中设置 mypackage 控制台处理程序，并在代码中更改其日志级别，如下所示：

def setup_logging(loglevel):
    logging.config.fileConfig('data/mypackage.logging.conf')

    logger = logging.getLogger('mypackage')
    console_handler = logger.getHandler('consoleHandler')
    console_handler.setLevel(getattr(logging, loglevel))

也不需要重新创建格式化程序...

（最后更新：是的，我知道 https://docs.python.org/3/library/logging.config.html#incremental-configuration，但在这种情况下，我被 Python 2.6 困住了...... :-)

【问题讨论】：

您是要覆盖某些处理程序的日志级别，还是仅过滤？换句话说，logging.warn("foo") 应该作为DEBUG 转储到文件处理程序，还是不被文件处理程序记录？

如果您想得到答案，请花点时间制作一个小示例，而不是复制/粘贴大量代码。

【参考方案1】：

使用 dictConfig。这是在 dictConfig 中使用单独的句柄记录到多个文件的示例。这并不是您要寻找的内容，但您可以修改此示例并简单地更改您要使用的每个处理程序的级别。

import os, logging
from logging.config import dictConfig

FORMAT = "%(asctime)s app [%(thread)d] %(levelname)-5s %(name)s - %(message)s. [file=%(filename)s:%(lineno)d]"
DATE_FORMAT = None


def setup_logging(name, level="INFO", fmt=FORMAT):
    formatted = fmt.format(app=name)
    log_dir = r'C:/log_directory'
    if not os.path.exists(log_dir):
        os.makedirs(log_dir)

    logging_config = 
        "version": 1,
        'disable_existing_loggers': False,
        "formatters": 
            'standard': 
                'format': formatted
            
        ,
        "handlers": 
            'default': 
                'class': 'logging.StreamHandler',
                'formatter': 'standard',
                'level': level,
                'stream': 'ext://sys.stdout'
            ,
            'file': 
                'class': 'logging.handlers.TimedRotatingFileHandler',
                'when': 'midnight',
                'utc': True,
                'backupCount': 5,
                'level': level,
                'filename': '/log1.log'.format(log_dir),
                'formatter': 'standard',
            ,
            'file2': 
                'class': 'logging.handlers.TimedRotatingFileHandler',
                'when': 'midnight',
                'utc': True,
                'backupCount': 5,
                'level': level,
                'filename': '/log2.log'.format(log_dir),
                'formatter': 'standard',
            
        ,
        "loggers": 
            "": 
                'handlers': ['default', 'file'],
                'level': level
            ,
            "second_log": 
                'handlers': ['default', 'file2'],
                'level': level
            
        
    

    dictConfig(logging_config)

log.setup_logging(name="log-name", level=LEVEL
logger = logging.getLogger(__name__)
second_logger = logging.getLogger('second_log')
second_logger.propagate = False

【讨论】：

是的，我知道，它要简单得多...但是当我问这个问题时（4 年前 ;-)，我被 Python 2.6 困住了，而 dictConfig 出现在 Python 2.7 中。谢谢你的提示 ！ :-)

我不得不问，因为 Python docs 也不清楚......当您在处理程序和使用该处理程序的记录器中指定不同的“级别”时会发生什么？哪个优先？

我相信处理程序级别会优先考虑，但为了清楚起见，我建议将两者设置为相同级别。您可以在不使用处理程序的情况下从技术上进行设置，然后如果您有一个有意义的场景，则无需担心它们会有所不同..

无优先级，而消息仅在记录器和处理程序都具有足够高的日志级别时才通过。

【参考方案2】：

更新处理程序的方法：

import logging

from rootmodule.mymodule import mylogger

def update_handler_level(logger,  handler_type, level="INFO"):
    # if not root logger user logger.parent
    for handler in logger.handlers or logger.parent.handlers:
        if isinstance(handler, handler_type):
            print(handler.level)
            handler.setLevel(getattr(logging, level, "INFO"))
            print(handler.level)

mylogger.debug('test')
update_handler_level(mylogger, logging.StreamHandler)
mylogger.debug('test')

我的 logging.cfg 与您的非常相似，除了记录器名称 si 设置在一个常量模块中（可以在不破坏日志记录配置的情况下进行模块重命名）

要从命令行更新，您的 opts 值和 logging.Handler 子类名称之间必须有一个映射。