Question

我可以创建一个命名的子记录器，以便该记录器输出的所有日志都标有它的名称。我可以在我的函数/类/中使用该记录器。

但是，如果该代码调用另一个模块中的函数，该模块仅使用日志记录模块函数（该根记录器的代理）来使用日志记录，那么如何确保这些日志消息通过同一个记录器（或至少以相同的方式登录）？

例如：

main.py

import logging

import other

def do_stuff(logger):
    logger.info("doing stuff")
    other.do_more_stuff()

if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger("stuff")
    do_stuff(logger)

other.py

import logging

def do_more_stuff():
    logging.info("doing other stuff")

输出：

$ python main.py 
INFO:stuff:doing stuff
INFO:root:doing other stuff

我希望能够使两个日志行都标记为“stuff”，我希望能够只更改main.py。

如何在other.py中使用不同的记录器而不更改该模块？

Answer 1

这是我提出的解决方案：

使用线程本地数据存储上下文信息，并使用根记录器处理程序上的Filter将此信息添加到LogRecords，然后再发送它们。

context = threading.local()                                                      
context.name = None                                                              

class ContextFilter(logging.Filter):                                             

    def filter(self, record):                                                    
        if context.name is not None:                                             
            record.name = "%s.%s" % (context.name, record.name)              
        return True

这对我来说很好，因为我正在使用记录器名称来指示记录此消息时正在执行的任务。

然后，我可以使用上下文管理器或装饰器从特定的代码段中进行记录，就好像它是从特定的子记录器记录一样。

@contextlib.contextmanager                                                       
def logname(name):                                                               
    old_name = context.name                                                      
    if old_name is None:                                                         
        context.name = name                                                      
    else:                                                                        
        context.name = "%s.%s" % (old_name, name)                                

    try:                                                                                 
        yield                                                                        
    finally:                                                                         
        context.name = old_name                                                      

def as_logname(name):                                                            
    def decorator(f):                                                            
        @functools.wraps(f)                                                      
        def wrapper(*args, **kwargs):                                            
            with logname(name):                                                  
                return f(*args, **kwargs)                                        
        return wrapper                                                           
    return decorator

那么，我可以这样做：

with logname("stuff"):
    logging.info("I'm doing stuff!")
    do_more_stuff()

或：

@as_logname("things")
def do_things():
    logging.info("Starting to do things")
    do_more_stuff()

关键是do_more_stuff()执行的任何日志记录都将被记录，就像使用“stuff”或“things”子记录器记录一样，而根本不需要更改do_more_stuff()。

如果您要在不同的子记录器上使用不同的处理程序，此解决方案会出现问题。

Answer 2

使用logging.setLoggerClass以便其他模块使用的所有记录器都使用您的记录器子类（强调我的）：

告诉日志记录系统在实例化记录器时使用类klass。该类应定义__init__()，以便只需要一个name参数，而__init__()应该调用Logger.__init__()。 通常在需要使用自定义记录器行为的应用程序实例化任何记录器之前调用此函数。

Answer 3

这就是logging.handlers（或日志记录模块中的处理程序）的用途。除了创建记录器之外，还可以创建一个或多个处理程序以将记录信息发送到各个位置并将其添加到根记录器。大多数执行日志记录的模块都会创建一个记录器，这些记录器用于自己的目的，但依赖于控制脚本来创建处理程序。一些框架决定非常有用，并为您添加处理程序。

阅读logging docs，其全部内容。

（编辑）

logging.basicConfig（）是一个辅助函数，它向根记录器添加一个处理程序。您可以使用'format ='参数控制它使用的格式字符串。如果您只想让所有模块显示“stuff”，那么请使用logging.basicConfig(level=logging.INFO, format="%(levelname)s:stuff:%(message)s")。

Answer 4

logging.{info,warning,…}方法只调用名为Logger的{{1}}对象上的相应方法（参见logging module source），如果您知道root module只调用other模块导出的函数，你可以使用logging对象覆盖logging命名空间中的other模块：

logger

如何使记录模块功能使用不同的记录器？

4 个答案: