Python在不同的日志级别记录到多个处理程序? [英] Python logging to multiple handlers, at different log levels?

查看：103
本文介绍了Python在不同的日志级别记录到多个处理程序?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

伙计，

我正在摸索无法正确使用的python日志记录配置.

I'm scratching my head on a python logging config that I can't get right.

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

Let's say I have the following package installed:

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

由于该脚本可以交互使用，也可以从crontab运行，因此我有以下要求:

As the script can be used interactively or run from a crontab, I have the following requirements:

  1. 没有打印语句，所有内容都通过日志记录进行记录；

  1. no print statements, everything goes through logging;

日志，在调试级别始终使用 ；

log using a timedRotatingFileHandler, always at DEBUG level;

日志；

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

log to console, with level set by default to INFO or overridden through a command-line option.

问题是，我可以通过命令行更改日志级别，并且控制台日志级别也已更改，但是其他处理程序也已更改，我不想...:-/

Problem is, I can change the log level through the command-line and the console log level is changed accordingly, but the other handlers are also changed, which I don't want... :-/

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

In a logging config file, I'm not sure I understand the precedence between the root logger's level, other loggers' level and handlers' level settings.

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

Here is some sample code. Any clues will be appreciated :-)

# 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=('mypackage@someserver.somewhere.com', ('mypackage-alerts@somewhere.com',), '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

同时，我发现了此答案，并以此方式成功修改了我的代码:

In the meantime, I discovered this answer and successfully modified my code this way:

#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(
        'mypackage@someserver.somewhere.com', ('mypackage-alerts@somewhere.com',), '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文件...

Now, I'll try to translate this in a logging.config file...

更新2

这是我发现的最好的日志记录配置和代码组合.

Here is the best logging config and code combination I found.

在mypackage.logging.conf文件中，"mypackage"记录器为:

In the mypackage.logging.conf file, the "mypackage" logger is:

  • 仅使用文件和电子邮件处理程序进行设置；
  • 其传播设置为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=('mypackage@someserver.somewhere.com', ('mypackage-alerts@somewhere.com',), '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=

在脚本中:

In the script:

  1. 已读取日志配置；

  1. the logging config is read;

(重新创建)console_formatter;

a console_formatter is (re-)created;

从命令行选项创建具有日志级别的控制台处理程序，然后将其添加到"mypackage"记录器中.

a console handler is created with the log level from the command-line option, then added to the "mypackage" logger.

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

如果从配置文件中加载处理程序时，其名称可以寻址"，则事情将变得更加简单.

Things would be simpler if the handlers were "addressable" by name when loaded from a config file.

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

Then, we could have the mypackage console handler set up in the config file and its log level changed in the code like this:

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

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

There would no need to re-create a formatter either...

(最新更新:是的，我知道 https ://docs.python.org/3/library/logging.config.html#incremental-configuration ，但是在这种情况下，我仍然使用Python 2.6 ...:-)

(last update: yes, I'm aware of https://docs.python.org/3/library/logging.config.html#incremental-configuration, but in this case, I'm stuck with Python 2.6... :-)

推荐答案

一种更新处理程序的方法:

An approach to update your handler:

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与您的logging.cfg非常相似，除了记录器名称si设置在恒定模块中(可以在不破坏记录配置的情况下对模块进行重命名)

My logging.cfg is pretty similar than your except the fact that the logger name si set in a constant module (a can do module rename without breaking the logging configuration)

要从命令行更新，必须在opts值和logging.Handler子类名称之间建立映射.

To update from command line, you must have a mapping between your opts value and logging.Handler sub class name.

这篇关于Python在不同的日志级别记录到多个处理程序?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！

查看全文
相关文章
Python最新文章
热门教程
热门工具
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆