logging 模块
# 1. 直接使用 logging, 会受到前面对 logging 的设置的影响,默认情况下窗口显示
import logging
# logging提供多种级别的日志信息,如: NOTSET(值为0), DEBUG(10), INFO(20), WARNING(默认值30), ERROR(40),
CRITICAL(50)等。每个级别都对应一个数值。
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(module)s.%(funcName)s %(lineno)s: %(levelname)s : %(message)s',
datefmt='%Y-%m-%d %X', filename='log.log')
logging.info('logging message')
# 2. 按自己需要设置 log 后再使用
def initlog():
import logging
logger = logging.getLogger() # 生成一个日志对象,可以带一个名字,可以缺省
hdlr = logging.FileHandler('crawl.log') # 生成一个Handler。logging支持许多Handler,象FileHandler,
SocketHandler, SMTPHandler等,我由于要写文件就使用了FileHandler。
# 生成一个格式器,用于规范日志的输出格式。
# 如果没有这行代码,那么缺省的格式就是:"%(message)s"。也就是写日志时,信息是什么日志中就是什么,没有日期,
没有信息级别等信息。
# logging支持许多种替换值,详细请看Formatter的文档说明。这里有三项:时间,信息级别,日志信息。
formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')
hdlr.setFormatter(formatter) # 将格式器设置到处理器上
#logger.addHandler(hdlr) # 将处理器加到日志对象上
# 上面使用 addHandler 会有两份日志输出,一份输出到文件(新加的 handler),一份输出到屏幕(默认的 handler)。
logger.handlers = [hdlr] # 这样写则只有一份日志输出,消耗更少、效率更高。
# 设置日志信息输出的级别。如果不执行此句,缺省为30(WARNING)。
# 可以执行:logging.getLevelName(logger.getEffectiveLevel())来查看缺省的日志级别。日志对象对于不同的级别
信息提供不同的函数进行输出,如:info(), error(), debug()等。
# 当写入日志时,小于指定级别的信息将被忽略。因此为了输出想要的日志级别一定要设置好此参数。这里我设为NOTSET(值为0),
也就是想输出所有信息。
logger.setLevel(logging.NOTSET)
return logger
# 使用日志对象:
logger = initlog()
logger.info('message info')
logger.error('message error')
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的级别。
示例(log_test.py 文件):
import logging
import logging.handlers
LOG_FILE = 'tst.log'
# 注意,按大小拆分、按时间拆分,是两个不同的 handler 类
handler = logging.handlers.RotatingFileHandler(LOG_FILE, maxBytes = 1024*1024, backupCount = 5)
# 实例化handler,文件到达一定大小时拆分
handler = logging.handlers.TimedRotatingFileHandler(LOG_FILE, when='midnight', backupCount = 10)
# 凌晨时拆分log文件,以免文件太大
# 上面的 backupCount参数 用于指定保留的log备份文件的个数,如写 10 表示最多保留 10 个 log备份文件
fmt = '%(asctime)s - %(filename)s:%(lineno)s - %(name)s - %(message)s'
formatter = logging.Formatter(fmt) # 实例化formatter
handler.setFormatter(formatter) # 为handler添加formatter
logger = logging.getLogger('tst') # 获取名为tst的logger
logger.addHandler(handler) # 为logger添加handler
logger.setLevel(logging.DEBUG)
logger.info('first info message') # 输出到 log 文件
logger.debug('first debug message')
输出结果:
2012-03-04 23:21:59,682 - log_test.py:16 - tst - first info message
2012-03-04 23:21:59,682 - log_test.py:17 - tst - first debug message
关于 formatter 的配置,采用的是%(<dict key>)s的形式,就是字典的关键字替换。提供的关键字包括:
Format Description
%(name)s Logger 的名字。 Name of the logger (logging channel).
%(levelno)s 数字形式的日志级别。 Numeric logging level for the message
(DEBUG, INFO, WARNING, ERROR, CRITICAL).
%(levelname)s 文本形式的日志级别。 Text logging level for the message
('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL').
%(pathname)s 调用日志输出函数的模块的完整路径名,可能没有。 Full pathname of the source file
where the logging call was issued (if available).
%(filename)s 调用日志输出函数的模块的文件名。 Filename portion of pathname.
%(module)s 调用日志输出函数的模块名。 Module (name portion of filename).
%(funcName)s 调用日志输出函数的函数名。 Name of function containing the logging call.
%(lineno)d 调用日志输出函数的语句所在的代码行。 Source line number where the logging
call was issued (if available).
%(created)f 当前时间,用UNIX标准的表示时间的浮点数表示。 Time when the LogRecord was
created (as returned by time.time()).
%(relativeCreated)d 输出日志信息时的,自Logger创建以来的毫秒数。 Time in milliseconds when the
LogRecord was created, relative to the time the logging module was loaded.
%(asctime)s 字符串形式的当前时间。默认格式是“2003-07-08 16:49:45,896”。逗号后面的是毫秒。
Human-readable time when the LogRecord was created.
By default this is of the form “2003-07-08 16:49:45,896” (the numbers after
the comma are millisecond portion of the time).
%(msecs)d Millisecond portion of the time when the LogRecord was created.
%(thread)d 线程ID。可能没有。 Thread ID (if available).
%(threadName)s 线程名。可能没有。 Thread name (if available).
%(process)d 进程ID。可能没有。 Process ID (if available).
%(message)s 用户输出的消息。 The logged message, computed as msg % args.
这个是摘自官网,提供了很多信息。
logging的配置
logging的配置可以采用python代码或是配置文件。
python代码的方式就是在应用的主模块中,构建handler,handler,formatter等对象。
而配置文件的方式是将这些对象的依赖关系分离出来放在文件中。比如前面的例子就类似于python代码的配置方式。
示例(采用配置文件的方式):
import logging
import logging.config
logging.config.fileConfig("logging.conf") # 采用配置文件
# create logger
logger = logging.getLogger("simpleExample") # 获取名为 simpleExample 的 logger, 对应配置文件的
[logger_simpleExample]
# "application" code
logger.debug("debug message")
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
logger.critical("critical message")
配置文件 logging.conf 的内容:
[loggers]
keys=root,simpleExample
[handlers]
keys=consoleHandler
[formatters]
keys=simpleFormatter
[logger_root]
level=DEBUG
handlers=consoleHandler
[logger_simpleExample]
level=DEBUG
handlers=consoleHandler
qualname=simpleExample
propagate=0
[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=simpleFormatter
args=(sys.stdout,)
[formatter_simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=
loggin.conf采用了模式匹配的方式进行配置,正则表达式是r'^[(.*)]$',从而匹配出所有的组件。
对于同一个组件具有多个实例的情况使用逗号','进行分隔。
对于一个实例的配置采用componentName_instanceName配置块。
使用这种方式还是蛮简单的。
在指定handler的配置时,class是具体的handler类的类名,可以是相对logging模块或是全路径类名,比如需要RotatingFileHandler,
则class的值可以为: RotatingFileHandler 或者logging.handlers.RotatingFileHandler 。
args就是要传给这个类的构造方法的参数,就是一个元组,按照构造方法声明的参数的顺序。
这里还要明确一点,logger对象是有继承关系的,比如名为a.b和a.c的logger都是名为a的子logger,并且所有的logger对象都继承于root。
如果子对象没有添加handler等一些配置,会从父对象那继承。这样就可以通过这种继承关系来复用配置。
多模块使用 logging
logging模块保证在同一个python解释器内,多次调用logging.getLogger('log_name')都会返回同一个logger实例,即使是在
多个模块的情况下。
所以典型的多模块场景下使用logging的方式是在main模块中配置logging,这个配置会作用于多个的子模块,然后在其他模块中直
接通过getLogger获取Logger对象即可。
示例:
配置文件 logging.conf 的内容:
[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,控制台输出所有log信息
但 tst.log 中没有root logger输出的信息,因为logging.conf中配置了只有main logger及其子logger使用RotatingFileHandler,
而root logger是输出到标准输出。
出错时发邮件
import os
import logging
import logging.handlers
def init_log(logfile, backupCount, debug=True):
'''初始化日志'''
log_path = os.path.dirname(logfile)
if not os.path.isdir(log_path):
os.makedirs(log_path)
logger = logging.getLogger()
formatter = logging.Formatter("[%(asctime)s]: %(module)s %(levelname)s %(message)s ")
# 文件 log 输出
#handler_record = logging.FileHandler(logfile)
handler_record = logging.handlers.TimedRotatingFileHandler(logfile, when='midnight', backupCount=backupCount)
handler_record.setFormatter(formatter)
logger.addHandler(handler_record)
if debug:
logger.setLevel(logging.DEBUG)
handler_record.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.WARNING)
handler_record.setLevel(logging.WARNING)
# 邮件 log 输出
handler_email = logging.handlers.SMTPHandler(
"mail.guoling.com", # 邮件服务器
"[email protected]", # 发出邮件的地址
"[email protected]", # 接收邮件的地址。 发给多个人则用列表(如:['[email protected]',
'[email protected]']),用字符串则只发给第一个
"test email logging", # 邮件主题
("[email protected]", "guoling") # 凭证(CREDENTIALS)
)
handler_email.setFormatter(formatter)
handler_email.setLevel(logging.ERROR)
email_logger = logging.getLogger('email') # 定义发邮件的 logger
email_logger.addHandler(handler_email)
email_logger.setLevel(logging.ERROR)
# http 的 log 输出
http_handler = logging.handlers.HTTPHandler('127.0.0.1:3333','/log/', method='GET')
http_handler.setFormatter(formatter)
http_handler.setLevel(logging.ERROR)
# 调用 logger
init_log('./log/run.log', 30, False) # 初始化
#os.remove('./log/run.log')
logging.error(u"logging.error 测试。。。") # 普通的 log,写到文件上
email_logger = logging.getLogger('email') # 需要发邮件的 log
msg = "email_logger.error gbk 测试 2..."
msg = msg.decode(sys.stdin.encoding).encode('gbk') # 处理中文,让 foxmail 显示正常
email_logger.error(msg) # 会发出邮件,并且也写到文件上
第三方模块 mlogging
====================================
https://pypi.python.org/pypi/mlogging/
使用好处:
发起多线程写log,性能优化
缺点:
windows 下貌似不能用
安装:
# linux 下 easy_install
sudo easy_install mlogging