python日志管理模块logging学习

Logging基础

python的日志管理模块logging是python的核心模块之一。先看一个小例子：

import logginglogging.debug('This is debug message')logging.info('This is info message')logging.warning('This is warning message')logging.error('This is error message')

输出信息为：

>>> 

WARNING:root:This is warning message
ERROR:root:This is error message

>>> 

没有输出info和debug的信息的原因，请看下面。

python的日志级别有六种：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，每一个level与一个整数数值。默认日志级别位WARNING，因此只有level高于等于WARNING，或对应整数值大于等于30的日志信息会被输出，如下表：

输出日志的级别可以自定义：

    logging.basicConfig(level=logging.NOTSET)       #改变日志输出级别    logging.addLevelName(60,'myLoggingLevel')       #自定义日志的对应的整数    logging.log(60, 'This is myLoggingLevel message')    logging.log(50, 'This is critical message')    logging.log(40, 'This is error message')    logging.log(30, 'This is warning message')    logging.log(20, 'This is info message')    logging.log(10, 'This is debug message')

输出

>>> 

myLoggingLevel:root:This is myLoggingLevel message
CRITICAL:root:This is critical message
ERROR:root:This is error message
WARNING:root:This is warning message
INFO:root:This is info message
DEBUG:root:This is debug message
>>> 

其中，logging.basicConfig函数各参数:
filename: 指定日志文件名
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
 %(levelno)s: 打印日志级别的数值
 %(levelname)s: 打印日志级别名称
 %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
 %(filename)s: 打印当前执行程序名
 %(funcName)s: 打印日志的当前函数
 %(lineno)d: 打印日志的当前行号
 %(asctime)s: 打印日志的时间
 %(thread)d: 打印线程ID
 %(threadName)s: 打印线程名称
 %(process)d: 打印进程ID
 %(message)s: 打印日志信息

例子

import logginglogging.basicConfig(level=logging.DEBUG,                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', #日志输出的内容                datefmt='%a, %d %b %Y %H:%M:%S',     #日期格式                filename='myapp.log',                #日志文件位置,若不定义，则默认输出在console上                filemode='w')                        #文件打开方式    logging.debug('This is debug message')logging.info('This is info message')logging.warning('This is warning message')

<span style="margin: 0px; padding: 0px; font-family: 'Courier New'; font-size: 13px; line-height: 18px; word-break: normal; word-wrap: normal; background-color: rgb(241, 241, 241);"><span style="margin: 0px; padding: 0px;">./myapp.log文件中内容为:</span></span><br style="margin: 0px; padding: 0px; color: rgb(0, 0, 255); font-family: 'Courier New'; font-size: 13px; line-height: 18px; background-color: rgb(241, 241, 241);" /><span style="color: rgb(0, 0, 255); font-family: 'Courier New'; font-size: 13px; line-height: 18px; background-color: rgb(241, 241, 241);">Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug message</span><br style="margin: 0px; padding: 0px; color: rgb(0, 0, 255); font-family: 'Courier New'; font-size: 13px; line-height: 18px; background-color: rgb(241, 241, 241);" /><span style="color: rgb(0, 0, 255); font-family: 'Courier New'; font-size: 13px; line-height: 18px; background-color: rgb(241, 241, 241);">Sun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info message</span><br style="margin: 0px; padding: 0px; color: rgb(0, 0, 255); font-family: 'Courier New'; font-size: 13px; line-height: 18px; background-color: rgb(241, 241, 241);" /><span style="color: rgb(0, 0, 255); font-family: 'Courier New'; font-size: 13px; line-height: 18px; background-color: rgb(241, 241, 241);">Sun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message</span>

Logger, Handler，Formatter，Filter的概念

先简单介绍一下，logging库提供了多个组件：Logger、Handler、Filter、Formatter。
Logger       对象提供应用程序可直接使用的接口，
Handler      发送日志到适当的目的地，
Filter          提供了过滤日志信息的方法，
Formatter   指定日志显示格式。

Logger是一个树形层级结构，输出信息之前都要获得一个Logger（如果没有显示的获取则自动创建并使用root Logger，如第一个例子所示）。
logger = logging.getLogger()    返回一个默认的Logger也即root Logger，并应用默认的日志级别、Handler和Formatter设置。
当然也可以通过Logger.setLevel(lel)指定最低的日志级别，可用的日志级别有：
logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()
输出不同级别的日志，只有日志等级大于或等于设置的日志级别的日志才会被输出。

如果查看python源代码，可以看到logger是logging模块里的一个类，通过getLogger()可以获得logger对象的一个实例：

def getLogger(name=None):    """    Return a logger with the specified name, creating it if necessary.    If no name is specified, return the root logger.    """    if name:        return Logger.manager.getLogger(name)       else:        return root         #root是Logger子类rootLogger的一个实例，默认级别为WARNING

看下面的代码：

root = RootLogger(WARNING)Logger.root = rootLogger.manager = Manager(Logger.root)class RootLogger(Logger):    """    A root logger is not that different to any other logger, except that    it must have a logging level and there is only one instance of it in    the hierarchy.    """    def __init__(self, level):        """        Initialize the logger with the name "root".        """        Logger.__init__(self, "root", level)

因此，如果不想getLogger()中传入参数，会返回一个root，这个root只能有一个实例，如果在其他地方再次调用getLogger()函数，只会获得一个root的引用。如果传入一个参数作为logger name，通过Manager生成一个Logger对象，并将这个对象加入日志Logger的字典列表中，logger name作为字典的键。当然，在一般使用中不需要了解这么深入的实现。看个例子：

logger1 = logging.getLogger("logger1")logger2 = logging.getLogger("looger2")logger1.setLevel(logging.DEBUG)logger2.setLevel(logging.NOTSET)logger1.info("Logger1 info messsage")logger2.debug("Logger2 debug message")

>>> 

INFO:logger1:Logger1 info messsage
DEBUG:looger2:Logger2 debug message

>>> 

logger有很多重要的api，参见

https://docs.python.org/3/library/logging.html?highlight=addlevelname#logging.basicConfig

logger中可以添加Handler，最常见的两种是输出到文件的FileHandler和console台的StreamHandler

# 创建一个handler，用于写入日志文件    fh = logging.FileHandler('/tmp/test.log')    # 再创建一个handler，用于输出到控制台    ch = logging.StreamHandler()    # 定义handler的输出格式formatter    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  fh.setFormatter(formatter)  ch.setFormatter(formatter)logger.addHandler(fh)  logger.addHandler(ch)

Handler

同样可以使用setLevel()设置日志级别，但是要注意，如果这个设置会被logger的级别覆盖。因此如果要在handler中定义日志级别，必须使logger的级别与之保持一致

上述例子的输出在标准输出和指定的日志文件中均可以看到，这是因为我们定义并使用了两种Handler。

[python] view plaincopy

1. fh = logging.FileHandler('/tmp/test.log')   
2. ch = logging.StreamHandler()  

Handler对象负责发送相关的信息到指定目的地，有几个常用的Handler方法：
Handler.setLevel(lel):        指定日志级别，低于lel级别的日志将被忽略
Handler.setFormatter()：  给这个handler选择一个Formatter
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

可以通过addHandler()方法为Logger添加多个Handler：

[python] view plaincopy

1. logger.addHandler(fh)  
2. logger.addHandler(ch)  

有多中可用的Handler：

logging.StreamHandler          可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息
logging.FileHandler                用于向一个文件输出日志信息
logging.handlers.RotatingFileHandler        类似于上面的FileHandler，但是它可以管理文件大小。
                                                                  当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建一个新的同名日志文件继续输出
logging.handlers.TimedRotatingFileHandler 和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就自动创建新的日志文件
logging.handlers.SocketHandler                  使用TCP协议，将日志信息发送到网络。
logging.handlers.DatagramHandler             使用UDP协议，将日志信息发送到网络。
logging.handlers.SysLogHandler                 日志输出到syslog
logging.handlers.NTEventLogHandler         远程输出日志到Windows NT/2000/XP的事件日志 
logging.handlers.SMTPHandler                   远程输出日志到邮件地址
logging.handlers.MemoryHandler                日志输出到内存中的制定buffer
logging.handlers.HTTPHandler                    通过"GET"或"POST"远程输出到HTTP服务器
各个Handler的具体用法可查看参考书册：
https://docs.python.org/2/library/logging.handlers.html#module-logging.handlers

3. Formatter

Formatter对象设置日志信息最后的规则、结构和内容，默认的时间格式为%Y-%m-%d %H:%M:%S。

[python] view plaincopy

1. #定义Formatter  
2. formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  
3. #为Handler添加Formatter  
4. fh.setFormatter(formatter)  
5. ch.setFormatter(formatter)  

Formatter参数中可能用到的格式化串参见上文（logging.basicConfig()函数format参数中可能用到的格式化串：）

Filter

限制只有满足过滤规则的日志才会输出。
比如我们定义了filter = logging.Filter('a.b.c'),并将这个Filter添加到了一个Handler上，
则使用该Handler的Logger中只有名字带a.b.c前缀的Logger才能输出其日志。

取消下列两行程序的注释

[python] view plaincopy

1. #filter = logging.Filter('mylogger.child1.child2')  
2. #fh.addFilter(filter)  

当然也可以直接给Logger加Filter。
若为Handler加Filter则所有使用了该Handler的Logger都会受到影响。而为Logger添加Filter只会影响到自身。
注释掉

[python] view plaincopy

1. #fh.addFilter(filter)   

并取消如下几行的注释

[python] view plaincopy

1. #logger.addFilter(filter)  
2. #logger1.addFilter(filter)  
3. #logger3.addFilter(filter)  
4. #logger4.addFilter(filter)  

除了直接在程序中设置Logger，Handler,Filter,Formatter外还可以

例如典型的logging.conf

[python] view plaincopy

1. [loggers]  
2. keys=root,simpleExample  
3.   
4. [handlers]  
5. keys=consoleHandler  
6.   
7. [formatters]  
8. keys=simpleFormatter  
9.   
10. [logger_root]  
11. level=DEBUG  
12. handlers=consoleHandler  
13.   
14. [logger_simpleExample]  
15. level=DEBUG  
16. handlers=consoleHandler  
17. qualname=simpleExample  
18. propagate=0  
19.   
20. [handler_consoleHandler]  
21. class=StreamHandler  
22. level=DEBUG  
23. formatter=simpleFormatter  
24. args=(sys.stdout,)  
25.   
26. [formatter_simpleFormatter]  
27. format=%(asctime)s - %(name)s - %(levelname)s - %(message)s  
28. datefmt=  

程序可以这么写

[python] view plaincopy

1. import logging    
2. import logging.config    
3.     
4. logging.config.fileConfig("logging.conf")    # 采用配置文件     
5.     
6. # create logger     
7. logger = logging.getLogger("simpleExample")    
8.     
9. # "application" code     
10. logger.debug("debug message")    
11. logger.info("info message")    
12. logger.warn("warn message")    
13. logger.error("error message")    
14. logger.critical("critical message")  

五、多模块使用logging

logging模块保证在同一个python解释器内，多次调用logging.getLogger('log_name')都会返回同一个logger实例，即使是在多个模块的情况下。
所以典型的多模块场景下使用logging的方式是在main模块中配置logging，这个配置会作用于多个的子模块，
然后在其他模块中直接通过getLogger获取Logger对象即可。

main.py：

[python] view plaincopy

1. import logging    
2. import logging.config    
3.     
4. logging.config.fileConfig('logging.conf')    
5. root_logger = logging.getLogger('root')    
6. root_logger.debug('test root logger...')    
7.     
8. logger = logging.getLogger('main')    
9. logger.info('test main logger')    
10. logger.info('start import module \'mod\'...')    
11. import mod    
12.     
13. logger.debug('let\'s test mod.testLogger()')    
14. mod.testLogger()    
15.     
16. root_logger.info('finish test...')   

子模块mod.py：

[python] view plaincopy

1. import logging    
2. import submod    
3.     
4. logger = logging.getLogger('main.mod')    
5. logger.info('logger of mod say something...')    
6.     
7. def testLogger():    
8.     logger.debug('this is mod.testLogger...')    
9.     submod.tst()   

子子模块submod.py：

[python] view plaincopy

1. import logging    
2.     
3. logger = logging.getLogger('main.mod.submod')    
4. logger.info('logger of submod say something...')    
5.     
6. def tst():    
7.     logger.info('this is submod.tst()...')