赞
踩
目录
Logger.debug(msg [ ,*args [, **kwargs]])
Logger.info(msg[ , *args[ , **kwargs] ] )
Logger.warnning(msg[ , *args[ , **kwargs] ] )
Logger.error(msg[ , *args[ , **kwargs] ] )
Logger.critical(msg[ , *args[ , **kwargs] ] )
Logger.log(lvl, msg[ , *args[ , **kwargs] ] )
Logger.exception(msg[, *args])
Logger.makeRecord(name, lvl, fn, lno, msg, args, exc_info[, func, extra])
https://www.cnblogs.com/deeper/p/7404190.html (较全,详细)
https://www.cnblogs.com/liujiacai/p/7804848.html
日志回滚:https://www.cnblogs.com/andy9468/p/8378492.html
logging模块是Python内置的标准模块,主要用于输出运行日志,可以设置输出日志的等级、日志保存路径、日志文件回滚等;相比print,具备如下优点:
(https://www.cnblogs.com/deeper/p/7404190.html)
主要包括四部分:
loggers 就是程序可以直接调用的一个日志接口,可以直接向logger写入日志信息。logger并不是直接实例化使用的,而是通过logging.getLogger(name)来获取对象,事实上logger对象是单例模式,logging是多线程安全的,也就是无论程序中哪里需要打日志获取到的logger对象都是同一个。但是不幸的是logger并不支持多进程。
【注意】loggers对象是有父子关系的,当没有父logger对象时它的父对象是root,当拥有父对象时父子关系会被修正。举个例子,logging.getLogger("abc.xyz") 会创建两个logger对象,一个是abc父对象,一个是xyz子对象,同时abc没有父对象,所以它的父对象是root。但是实际上abc是一个占位对象(虚的日志对象),可以没有handler来处理日志。但是root不是占位对象,如果某一个日志对象打日志时,它的父对象会同时收到日志,所以有些使用者发现创建了一个logger对象时会打两遍日志,就是因为他创建的logger打了一遍日志,同时root对象也打了一遍日志。
Handlers 将logger发过来的信息进行准确地分配,送往正确的地方。举个栗子,送往控制台或者文件或者both或者其他地方(进程管道之类的)。它决定了每个日志的行为,是之后需要配置的重点区域。
每个Handler同样有一个日志级别,一个logger可以拥有多个handler也就是说logger可以根据不同的日志级别将日志传递给不同的handler。当然也可以相同的级别传递给多个handlers这就根据需求来灵活的设置了。
Filters 提供了更细粒度的判断,来决定日志是否需要打印。原则上handler获得一个日志就必定会根据级别被统一处理,但是如果handler拥有一个Filter可以对日志进行额外的处理和判断。例如Filter能够对来自特定源的日志进行拦截or修改甚至修改其日志级别(修改后再进行级别判断)。
logger和handler都可以安装filter甚至可以安装多个filter串联起来。
Formatters 指定了最终某条记录打印的格式布局。Formatter会将传递来的信息拼接成一条具体的字符串,默认情况下Format只会将信息%(message)s直接打印出来。Format中有一些自带的LogRecord属性可以使用,如下表格:
一个Handler只能拥有一个Formatter 因此如果要实现多种格式的输出只能用多个Handler来实现。
一个简单的例子:
- import logging
-
- # logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
- # logging中可以选择很多消息级别,如debug、info、warning、error以及critical。
- # 通过赋予logger或者handler不同的级别,开发者就可以只输出错误信息到特定的记录文件,或者在调试时只记录调试信息。
- logging.basicConfig(level = logging.DEBUG,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
- logger = logging.getLogger(__name__)
-
- logger.info("Start print log")
- logger.debug("Do something")
- logger.warning("Something maybe fail.")
- logger.info("Finish")
终端输出:
filename:指定日志文件名,日志文件的保存路径。如果配置了些参数,将自动创建一个FileHandler作为Handler;
filemode:和file函数意义相同,指定日志文件的打开模式,'w'或者'a',默认值为’a’,表示日志消息以追加的形式添加到日志文件中。如果设为’w’, 那么每次程序启动的时候都会创建一个新的日志文件;
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:打印日志信息
datefmt:指定时间格式,同time.strftime();
level:设置日志级别,默认为logging.WARNNING。
可以给日志对象(Logger Instance)设置日志级别,低于该级别的日志消息将会被忽略,也可以给Hanlder设置日志级别,对于低于该级别的日志消息, Handler也会忽略。
可以设置不同的日志等级,用于控制日志的输出,
- 日志等级:使用范围
-
- FATAL:致命错误
- CRITICAL:特别糟糕的事情,如内存耗尽、磁盘空间为空,一般很少使用
- ERROR:发生错误时,如IO操作失败或者连接问题
- WARNING:发生很重要的事件,但是并不是错误时,如用户登录密码错误
- INFO:处理请求或者状态变化等日常事务
- DEBUG:调试过程中使用DEBUG等级,如算法中每个循环的中间状态
stream:指定日志的输出流,可以指定输出到sys.stderr,sys.stdout或者文件,默认输出到sys.stderr,当stream和filename同时指定时,stream被忽略。
创建Logger对象。日志记录的工作主要由Logger对象来完成。在调用getLogger时要提供Logger的名称(注:多次使用相同名称来调用getLogger,返回的是同一个对象的引用。),Logger实例之间有层次关系,这些关系通过Logger名称来体现,如:
p = logging.getLogger(“root”)
c1 = logging.getLogger(“root.c1”)
c2 = logging.getLogger(“root.c2”)
例子中,p是父logger, c1,c2分别是p的子logger。c1, c2将继承p的设置。如果省略了name参数, getLogger将返回日志对象层次关系中的根Logger。
获取日志级别对应的名称。
- #下面的结果都为DEBUG
- print logging.getLevelName(10)
- print logging.getLevelName(logging.DEBUG)
- #下面的结果都为ERROR
- print logging.getLevelName(40)
- print logging.getLevelName(logging.ERROR)
当不再使用日志系统的时候,调用该方法,它会将日志flush到对应的目标域上。一般在系统退出的时候调用。
设置日志的级别。对于低于该级别的日志消息将被忽略。
记录DEBUG级别的日志信息。参数msg是信息的格式,args与kwargs分别是格式参数。
记录相应级别的日志信息。参数的含义与Logger.debug一样。
添加/移除日志消息处理器。在讲述Handler时具体介绍。
记录日志,参数lvl用户设置日志信息的级别。参数msg, *args, **kwargs的含义与Logger.debug一样。
以ERROR级别记录日志消息,异常跟踪信息将被自动添加到日志消息里。
创建LogRecord对象。日志消息被实例为一个LogRecord对象,并在日志类内处理。
添加/移除日志消息过滤器。
- import logging
-
- logger = logging.getLogger(__name__)
- logger.setLevel(level = logging.INFO) # 控制等级
- handler = logging.FileHandler("log.txt") # 将日志写入到文件
- #对输出消息的格式进行设置,将其添加到logger
- handler.setLevel(logging.INFO)
- formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
- handler.setFormatter(formatter)
- logger.addHandler(handler)
-
- logger.info("Start print log")
- logger.debug("Do something")
- logger.warning("Something maybe fail.")
- logger.info("Finish")
设置logging,创建一个FileHandler,并对输出消息的格式进行设置,将其添加到logger,然后将日志写入到指定的文件中,之前出现在终端的数据就会直接被写入到文件。(跟之前内容不同,因为level变了)
- '''写入文件并显示到终端'''
- import logging
- logger = logging.getLogger(__name__)
- logger.setLevel(level = logging.INFO)
- handler = logging.FileHandler("log.txt")
- handler.setLevel(logging.INFO)
- formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
- handler.setFormatter(formatter)
-
- console = logging.StreamHandler()
- console.setLevel(logging.INFO)
-
- logger.addHandler(handler)
- logger.addHandler(console)
-
- logger.info("Start print log")
- logger.debug("Do something")
- logger.warning("Something maybe fail.")
- logger.info("Finish")
可以发现,logging有一个日志处理的主对象,其他处理方式都是通过addHandler添加进去,logging中包含的handler主要有如下几种,
- handler名称:位置;作用
-
- StreamHandler:logging.StreamHandler;日志输出到流,可以是sys.stderr,sys.stdout或者文件
- FileHandler:logging.FileHandler;日志输出到文件
- BaseRotatingHandler:logging.handlers.BaseRotatingHandler;基本的日志回滚方式
- RotatingHandler:logging.handlers.RotatingHandler;日志回滚方式,支持日志文件最大数量和日志文件回滚
- TimeRotatingHandler:logging.handlers.TimeRotatingHandler;日志回滚方式,在一定时间区域内回滚日志文件
- SocketHandler:logging.handlers.SocketHandler;远程输出日志到TCP/IP sockets
- DatagramHandler:logging.handlers.DatagramHandler;远程输出日志到UDP sockets
- SMTPHandler:logging.handlers.SMTPHandler;远程输出日志到邮件地址
- SysLogHandler:logging.handlers.SysLogHandler;日志输出到syslog
- NTEventLogHandler:logging.handlers.NTEventLogHandler;远程输出日志到Windows NT/2000/XP的事件日志
- MemoryHandler:logging.handlers.MemoryHandler;日志输出到内存中的指定buffer
- HTTPHandler:logging.handlers.HTTPHandler;通过"GET"或者"POST"远程输出到HTTP服务器
日志回滚:(https://www.cnblogs.com/andy9468/p/8378492.html)
将日志信息输出到一个单一的文件中,随着应用程序的持续使用,该日志文件会越来越庞大,进而影响系统的性能。因此,有必要对日志文件按某种条件进行切分,要切分日志文件。
分割日志的触发条件:大小、日期,或者大小加上日期。
说是切分,实际上是,当一个日志文件达到触发条件后,对日志文件进行重命名,之后再新建原来名称的日志文件(此时就是空文件了),新产生的日志就写入新的日志文件。
为啥叫回滚呢?当分割的日志文件达到指定数目的上限个数时,最老的日志文件就会被删除。
(按时间分割日志,并且限制日志文件的个数,删除早期的日志)
TimeRotatingHandler:logging.handlers.TimeRotatingHandler;日志回滚方式,在一定时间区域内回滚日志文件
- '''日志回滚'''
- import time
- import logging
- import logging.handlers
-
- # logging初始化工作
- logging.basicConfig()
-
- # myapp的初始化工作
- myapp = logging.getLogger('myapp')
- myapp.setLevel(logging.INFO)
-
- # 添加TimedRotatingFileHandler
- # 定义一个1秒换一次log文件的handler
- # 保留3个旧log文件
- handler = logging.handlers.TimedRotatingFileHandler("爬虫项目douban/doubanTOP.log", when='S', interval=1, backupCount=3)
- # 设置后缀名称,跟strftime的格式一样
- handler.suffix = "%Y-%m-%d.log"#按天删
-
- formatter = logging.Formatter('%(asctime)s|%(name)-12s: %(levelname)-8s %(message)s')
- handler.setFormatter(formatter)
- myapp.addHandler(handler)
-
- while True:
- time.sleep(0.1)
- myapp.info("test")
-
- timefilehandler.suffix = "%Y-%m-%d_%H-%M-%S.log"#按秒删
- timefilehandler.suffix = "%Y-%m-%d.log"#按天删
NOTE:filehanlder.suffix的格式必须这么写,才能自动删除旧文件,写成其他格式会导致删除旧文件不生效。
TimedRotatingFileHandler的构造函数定义如下:
TimedRotatingFileHandler(filename [,when [,interval [,backupCount]]])
filename 是输出日志文件名的前缀,比如log/myapp.log
when 是一个字符串的定义如下:
“S”: Seconds
“M”: Minutes
“H”: Hours
“D”: Days
“W”: Week day (0=Monday)
“midnight”: Roll over at midnight
interval 是指等待多少个单位when的时间后,Logger会自动重建文件,当然,这个文件的创建
取决于filename+suffix,若这个文件跟之前的文件有重名,则会自动覆盖掉以前的文件,所以
有些情况suffix要定义的不能因为when而重复。
backupCount 是保留日志个数。默认的0是不会自动删除掉日志。若设3,则在文件的创建过程中
库会判断是否有超过这个3,若超过,则会从最先创建的开始删除。
RotatingFileHandler,基于文件大小切分。
- # logging初始化工作
- logging.basicConfig()
-
- # myapp的初始化工作
- myapp = logging.getLogger('myapp')
- myapp.setLevel(logging.INFO)
-
- # 写入文件,如果文件超过100个Bytes,仅保留5个文件。
- handler = logging.handlers.RotatingFileHandler(
- '爬虫项目douban/doubanTOP.log', maxBytes=500, backupCount=5)
-
- formatter = logging.Formatter('%(asctime)s|%(name)-12s: %(levelname)-8s %(message)s')
- handler.setFormatter(formatter)
- myapp.addHandler(handler)
-
- while True:
- time.sleep(0.1)
- myapp.info("test")
- try:
- '''
- do-something-block
- '''
- except:
- logger.exception("Exception Logged")
例如:
- #捕获异常Traceback
- try:
- open("sklearn.txt","rb")
- except (SystemExit,KeyboardInterrupt):
- raise
- except Exception:
- logger.error("Faild to open sklearn.txt from logger.error",exc_info = True)
也可以使用logger.exception(msg,_args),它等价于logger.error(msg,exc_info = True,_args),将
logger.error("Faild to open sklearn.txt from logger.error",exc_info = True)
替换为,
logger.exception("Failed to open sklearn.txt from logger.exception")
- import logging
-
- logger = logging.getLogger('mainModule')#主模块
- logger.setLevel(level=logging.INFO)
-
- formatter = logging.Formatter(
- '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-
- handler = logging.FileHandler('log.txt')
- handler.setLevel(logging.INFO)
- handler.setFormatter(formatter)
-
- console = logging.StreamHandler()
- console.setLevel(logging.INFO)
- console.setFormatter(formatter)
-
- logger.addHandler(handler)
- logger.addHandler(console)
-
- # 在其他模块导入该日志接口module_logger即可
- module_logger = logging.getLogger('mainModule.sub')#子模块
- module_logger.info('this is another module using logging')
说明:
首先定义了logger 'mainModule',并对它进行了配置,就可以在解释器进程里面的其他地方通过getLogger('mainModule')得到的对象都是一样的,不需要重新配置,可以直接使用。定义的该logger的子logger,都可以共享父logger的定义和配置,所谓的父子logger是通过命名来识别,任意以'mainModule'开头的logger都是它的子logger,例如'mainModule.sub'。
实际开发一个application,首先可以通过logging配置文件编写好这个application所对应的配置,可以生成一个根logger,如'PythonAPP',然后在主函数中通过fileConfig加载logging配置,接着在application的其他地方、不同的模块中,可以使用根logger的子logger,如'PythonAPP.Core','PythonAPP.Web'来进行log,而不需要反复的定义和配置各个模块的logger。
不太懂,暴力记录一下。
- #logger.conf
- ###############################################
- [loggers]
- keys=root,example01,example02
- [logger_root]
- level=DEBUG
- handlers=hand01,hand02
- [logger_example01]
- handlers=hand01,hand02
- qualname=example01
- propagate=0
- [logger_example02]
- handlers=hand01,hand03
- qualname=example02
- propagate=0
- ###############################################
- [handlers]
- keys=hand01,hand02,hand03
- [handler_hand01]
- class=StreamHandler
- level=INFO
- formatter=form02
- args=(sys.stderr,)
- [handler_hand02]
- class=FileHandler
- level=DEBUG
- formatter=form01
- args=('myapp.log', 'a')
- [handler_hand03]
- class=handlers.RotatingFileHandler
- level=INFO
- formatter=form02
- args=('myapp.log', 'a', 10*1024*1024, 5)
- ###############################################
- [formatters]
- keys=form01,form02
- [formatter_form01]
- format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s
- datefmt=%a, %d %b %Y %H:%M:%S
- [formatter_form02]
- format=%(name)-12s: %(levelname)-8s %(message)s
- datefmt=%a, %d %b %Y %H:%M:%S
- import logging
- import logging.config
-
- logging.config.fileConfig("logger.conf")
- logger = logging.getLogger("example01")
-
- logger.debug('This is debug message')
- logger.info('This is info message')
- logger.warning('This is warning message')
- import logging
- import logging.config
-
- logging.config.fileConfig("logger.conf")
- logger = logging.getLogger("example02")
-
- logger.debug('This is debug message')
- logger.info('This is info message')
- logger.warning('This is warning message')
- {
- "version":1,
- "disable_existing_loggers":false,
- "formatters":{
- "simple":{
- "format":"%(asctime)s - %(name)s - %(levelname)s - %(message)s"
- }
- },
- "handlers":{
- "console":{
- "class":"logging.StreamHandler",
- "level":"DEBUG",
- "formatter":"simple",
- "stream":"ext://sys.stdout"
- },
- "info_file_handler":{
- "class":"logging.handlers.RotatingFileHandler",
- "level":"INFO",
- "formatter":"simple",
- "filename":"info.log",
- "maxBytes":"10485760",
- "backupCount":20,
- "encoding":"utf8"
- },
- "error_file_handler":{
- "class":"logging.handlers.RotatingFileHandler",
- "level":"ERROR",
- "formatter":"simple",
- "filename":"errors.log",
- "maxBytes":10485760,
- "backupCount":20,
- "encoding":"utf8"
- }
- },
- "loggers":{
- "my_module":{
- "level":"ERROR",
- "handlers":["info_file_handler"],
- "propagate":"no"
- }
- },
- "root":{
- "level":"INFO",
- "handlers":["console","info_file_handler","error_file_handler"]
- }
- }
通过JSON加载配置文件,然后通过logging.dictConfig配置logging,
- import json
- import logging.config
- import os
-
- def setup_logging(default_path = "logging.json",default_level = logging.INFO,env_key = "LOG_CFG"):
- path = default_path
- value = os.getenv(env_key,None)
- if value:
- path = value
- if os.path.exists(path):
- with open(path,"r") as f:
- config = json.load(f)
- logging.config.dictConfig(config)
- else:
- logging.basicConfig(level = default_level)
-
- def func():
- logging.info("start func")
-
- logging.info("exec func")
-
- logging.info("end func")
-
- if __name__ == "__main__":
- setup_logging(default_path = "logging.json")
- func()
通过YAML文件进行配置,比JSON看起来更加简介明了,但我没学过YAML,先存下来。
https://www.cnblogs.com/deeper/p/7404190.html
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。