python 构建自己的log系统

python的logging模块提供了记录程序运行情况的日志功能,类似于Apache的log4j,很好很强大,这里我们就来看一下Python中内置的日志模块logging用法详解

logging模块简介

Python的logging模块提供了通用的日志系统，可以方便第三方模块或者是应用使用。这个模块提供不同的日志级别，并可以采用不同的方式记录日志，比如文件，HTTP GET/POST，SMTP，Socket等，甚至可以自己实现具体的日志记录方式。
logging模块与log4j的机制是一样的，只是具体的实现细节不同。模块提供logger，handler，filter，formatter。

• logger：提供日志接口，供应用代码使用。logger最长用的操作有两类：配置和发送日志消息。可以通过logging.getLogger(name)获取logger对象，如果不指定name则返回root对象，多次使用相同的name调用getLogger方法返回同一个logger对象。
• handler：将日志记录（log record）发送到合适的目的地（destination），比如文件，socket等。一个logger对象可以通过addHandler方法添加0到多个handler，每个handler又可以定义不同日志级别，以实现日志分级过滤显示。
•  filter：提供一种优雅的方式决定一个日志记录是否发送到handler。
•  formatter：指定日志记录输出的具体格式。formatter的构造方法需要两个参数：消息的格式字符串和日期字符串，这两个参数都是可选的。

与log4j类似，logger，handler和日志消息的调用可以有具体的日志级别（Level），只有在日志消息的级别大于logger和handler的级别。

logging用法解析

1. 初始化 logger = logging.getLogger("endlesscode")，getLogger()方法后面最好加上所要日志记录的模块名字，后面的日志格式中的%(name)s 对应的是这里的模块名字
2. 设置级别 logger.setLevel(logging.DEBUG),Logging中有NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL这几种级别，日志会记录设置级别以上的日志
3. Handler，常用的是StreamHandler和FileHandler，windows下你可以简单理解为一个是console和文件日志，一个打印在CMD窗口上，一个记录在一个文件上
4. formatter，定义了最终log信息的顺序,结构和内容，我喜欢用这样的格式 '[%(asctime)s] [%(levelname)s] %(message)s', '%Y-%m-%d %H:%M:%S'，
　　%(name)s Logger的名字
　　%(levelname)s 文本形式的日志级别
　　%(message)s 用户输出的消息
　　%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
　　%(levelno)s 数字形式的日志级别
　　%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
　　%(filename)s 调用日志输出函数的模块的文件名
　　%(module)s  调用日志输出函数的模块名
　　%(funcName)s 调用日志输出函数的函数名
　　%(lineno)d 调用日志输出函数的语句所在的代码行
　　%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
　　%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
　　%(thread)d 线程ID。可能没有
　　%(threadName)s 线程名。可能没有
　　%(process)d 进程ID。可能没有
5. 记录 使用object.debug(message)来记录日志

6. logging是线程安全的

简单示例如下：

　　

 1 import logging
 2 logger = logging.getLogger("simple_example")
 3 logger.setLevel(logging.DEBUG)
 4 # 建立一个filehandler来把日志记录在文件里，级别为debug以上
 5 fh = logging.FileHandler("spam.log")
 6 fh.setLevel(logging.DEBUG)
 7 # 建立一个streamhandler来把日志打在CMD窗口上，级别为error以上
 8 ch = logging.StreamHandler()
 9 ch.setLevel(logging.ERROR)
10 # 设置日志格式
11 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
12 ch.setFormatter(formatter)
13 fh.setFormatter(formatter)
14 #将相应的handler添加在logger对象中
15 logger.addHandler(ch)
16 logger.addHandler(fh)
17 # 开始打日志
18 logger.debug("debug message")
19 logger.info("info message")
20 logger.warn("warn message")
21 logger.error("error message")
22 logger.critical("critical message")

当你的项目较大时，你就需要一个比较方便规范的使用的方式，建议将你的kog系统设计为class方式，这样就可以方便使用

 1 #! /usr/bin/env python
 2 #coding=gbk
 3 import logging,os
 4  
 5 class Logger:
 6  def __init__(self, path,clevel = logging.DEBUG,Flevel = logging.DEBUG):
 7   self.logger = logging.getLogger(path)
 8   self.logger.setLevel(logging.DEBUG)
 9   fmt = logging.Formatter('[%(asctime)s] [%(levelname)s] %(message)s', '%Y-%m-%d %H:%M:%S')
10   #设置CMD日志
11   sh = logging.StreamHandler()
12   sh.setFormatter(fmt)
13   sh.setLevel(clevel)
14   #设置文件日志
15   fh = logging.FileHandler(path)
16   fh.setFormatter(fmt)
17   fh.setLevel(Flevel)
18   self.logger.addHandler(sh)
19   self.logger.addHandler(fh)
20  
21  def debug(self,message):
22   self.logger.debug(message)
23  
24  def info(self,message):
25   self.logger.info(message)
26  
27  def war(self,message):
28   self.logger.warn(message)
29  
30  def error(self,message):
31   self.logger.error(message)
32  
33  def cri(self,message):
34   self.logger.critical(message)
35  
36 if __name__ =='__main__':
37  logyyx = Logger('yyx.log',logging.ERROR,logging.DEBUG)
38  logyyx.debug('一个debug信息')
39  logyyx.info('一个info信息')
40  logyyx.war('一个warning信息')
41  logyyx.error('一个error信息')
42  logyyx.cri('一个致命critical信息')

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

[loggers]
keys=root,main

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=fmt

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_main]
level=DEBUG
qualname=main
handlers=fileHandler

[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=fmt
args=(sys.stdout,)

[handler_fileHandler]
class=logging.handlers.RotatingFileHandler
level=DEBUG
formatter=fmt
args=('tst.log','a',20000,5,)

[formatter_fmt]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=

主模块main.py：

import logging
import logging.config

logging.config.fileConfig( 'logging.conf' )
root_logger = logging.getLogger( 'root' )
root_logger.debug( 'test root logger...' )

logger = logging.getLogger( 'main' )
logger.info( 'test main logger' )
logger.info( 'start import module \'mod\'...' )
import mod

logger.debug( 'let\'s test mod.testLogger()' )
mod.testLogger()

root_logger.info( 'finish test...' )

子模块mod.py：

import logging
import submod

logger = logging.getLogger( 'main.mod' )
logger.info( 'logger of mod say something...' )

def testLogger():
  logger.debug( 'this is mod.testLogger...' )
  submod.tst()

子子模块submod.py：

import logging

logger = logging.getLogger( 'main.mod.submod' )
logger.info( 'logger of submod say something...' )

def tst():
  logger.info( 'this is submod.tst()...' )

然后运行python main.py，控制台输出：

2012-03-09 18:22:22,793 - root - DEBUG - test root logger...
2012-03-09 18:22:22,793 - main - INFO - test main logger
2012-03-09 18:22:22,809 - main - INFO - start import module 'mod'...
2012-03-09 18:22:22,809 - main.mod.submod - INFO - logger of submod say something...
2012-03-09 18:22:22,809 - main.mod - INFO - logger say something...
2012-03-09 18:22:22,809 - main - DEBUG - let's test mod.testLogger()
2012-03-09 18:22:22,825 - main.mod - DEBUG - this is mod.testLogger...
2012-03-09 18:22:22,825 - main.mod.submod - INFO - this is submod.tst()...
2012-03-09 18:22:22,841 - root - INFO - finish test...

可以看出，和预想的一样，然后在看一下tst.log，logger配置中的输出的目的地：

2012-03-09 18:22:22,793 - main - INFO - test main logger
2012-03-09 18:22:22,809 - main - INFO - start import module 'mod'...
2012-03-09 18:22:22,809 - main.mod.submod - INFO - logger of submod say something...
2012-03-09 18:22:22,809 - main.mod - INFO - logger say something...
2012-03-09 18:22:22,809 - main - DEBUG - let's test mod.testLogger()
2012-03-09 18:22:22,825 - main.mod - DEBUG - this is mod.testLogger...
2012-03-09 18:22:22,825 - main.mod.submod - INFO - this is submod.tst()...

另外在浏览网页时发现一个讲的比较好的：http://outofmemory.cn/code-snippet/450/python-rizhi-logging-module-usage-summary

下面这个是目前会用，但是不是甚懂的一个logger系统设计：

 1 import logging
 2 import logging.config
 3 
 4 class SpiderFilter(logging.Filter):
 5 
 6     def __init__(self, allow=None, disable=None):
 7         self.allow_channels = allow
 8         self.disable_channels = disable
 9 
10     def filter(self, record):
11         if self.allow_channels is not None:
12             if record.name in self.allow_channels:
13                 allow = True
14             else:
15                 allow = False
16         elif self.disable_channels is not None:
17             if record.name in self.disable_channels:
18                 allow = False
19             else:
20                 allow = True
21         else:
22             allow = False
23         return allow
24 
25 
26 LOGGING = {
27     'version': 1,
28     'disable_existing_loggers': True,
29     'formatters': {
30         'verbose': {
31             'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
32         },
33         'simple': {
34             'format': '%(asctime)s -- %(name)s !!!%(levelname)s!!!: %(message)s'
35         },
36     },
37     'filters': {
38         'basic': {
39             '()': SpiderFilter,
40             'allow': ('mongo', 'redis', 'mysql'),
41         },
42         'warn': {
43             '()': SpiderFilter,
44             'disable': ()
45         }
46     },
47     'handlers': {
48         'file': {
49             'level': 'WARN',
50             'formatter': 'simple',
51             'class': 'logging.FileHandler',
52             'filename': 'spider.log',
53             'mode': 'a',
54             'filters': ['warn']
55         },
56         'console': {
57             'level': 'DEBUG',
58             'class': 'logging.StreamHandler',
59             'formatter': 'simple'
60         },
61         'database': {
62             'level': 'DEBUG',
63             'class': 'logging.FileHandler',
64             'formatter': 'simple',
65             'filename': 'spider.log',
66             'mode': 'a',
67             'filters': ['basic']
68         }
69     },
70     'loggers': {
71         'mongo': {
72             'handlers':['file'],
73             'propagate': True,
74             'level':'ERROR',
75         },
76         'mysql': {
77             'handlers': ['database'],
78             'level': 'DEBUG',
79             'propagate': False,
80         },
81         'redis': {
82             'handlers': ['console', 'database'],
83             'level': 'INFO',
84             'filters': ['basic']
85         }
86     },
87     'root': {
88         'level': 'DEBUG',
89         'handlers': ['console']
90     }
91 }
92 
93 if __name__ == '__main__':
94     logging.config.dictConfig(LOGGING)
95     logging.getLogger('mysql').debug('Simple Log Test!')
96     logging.getLogger('mongo').critical('Test!')

 

转载于:https://www.cnblogs.com/crawer-1/p/8258146.html