如何使日志记录模块函数使用不同的日志记录程序？

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)

其他.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

这是我想出的解决方案：

使用线程本地数据存储上下文信息，并在根记录器处理程序上使用筛选器在发出日志记录之前将这些信息添加到日志记录中。

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

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