python日志设置[logging]

logging介绍

用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等;


优点：

• 可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；
• 可以由开发者决定将信息输出到什么地方，以及怎么输出(print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据)
  
  

日志级别

• DEBUG：最详细的日志信息，典型应用场景是 问题诊断
• INFO：信息详细程度仅次于DEBUG，通常只记录关键节点信息，用于确认一切都是按照我们预期的那样进行工作
• WARNING：当某些不期望的事情发生时记录的信息（如，磁盘可用空间较低），但是此时应用程序还是正常运行的
• ERROR：由于一个更严重的问题导致某些功能不能正常运行时记录的信息
• CRITICAL：当发生严重错误，导致应用程序不能继续运行时记录的信息

开发应用程序或部署开发环境时，可以使用DEBUG或INFO级别的日志获取尽可能详细的日志信息来进行开发或部署调试；
应用上线或部署生产环境时，应该使用WARNING或ERROR或CRITICAL级别的日志来降低机器的I/O压力和提高获取错误日志信息的效率。日志级别的指定通常都是在应用程序的配置文件中进行指定的；
日志等级是从上到下依次升高的，即：DEBUG < INFO < WARNING < ERROR < CRITICAL，而日志的信息量是依次减少的；
logging模块可以指定日志记录器的日志级别，只有级别大于或等于该指定日志级别的日志记录才会被输出，小于该等级的日志记录将会被丢弃。

一条日志信息对应一个事件的发生，通常包含以下几个内容：

1. 发生时间
2. 发生位置
3. 严重程度
4. 事件内容

logging模块可以支持日志格式自定义。

日志级别

logging模块中各等级的定义

• logging.CRITICAL = logging.FATAL = 50
• logging.ERROR = 40
• logging.WARNING = logging.WARN = 30
• logging.INFO = 20
• logging.DEBUG = 10
• logging.NOTSET = 0
  
  

logging输出不同级别日志

logging.debug(msg, *args, **kwargs) 创建一条严重级别为DEBUG的日志记录
logging.info(msg, *args, **kwargs) 创建一条严重级别为INFO的日志记录
logging.warning(msg, *args, **kwargs) 创建一条严重级别为WARNING的日志记录
logging.error(msg, *args, **kwargs) 创建一条严重级别为ERROR的日志记录
logging.critical(msg, *args, **kwargs) 创建一条严重级别为CRITICAL的日志记录
logging.log(level, *args, **kwargs) 创建一条严重级别为level的日志记录
logging.basicConfig(**kwargs) 对root logger进行一次性配置(用默认Formatter为日志系统建立一个StreamHandler，设置基础配置并加到root logger中)
logging.getLogger() 返回一个logger对象，如果没有指定名字将返回root logger

logging模块四大组件

• logger日志器： 提供日志接口，供应用程序调用。
• handler处理器：将logger创建的日志记录发送到合适的目的输出，如文件、socket等。 一个logger对象可以通过addHandler方法添加0到多个handler,每个handler又可以定义不同的日志级别，实现日志分级过滤显示。
• filter过滤器：提供了更细粒度的控制工具来决定发送哪条日志记录到handler，或丢弃哪条日志记录
• formatter格式器：决定日志记录的最终输出格式。 formatter的构造方法需要两个参数： 消息的格式字符串和日期字符串
  
  

Logger类

1、作用：

• 向应用程序代码暴露几个方法，使应用程序可以在运行时记录日志消息；
• 基于日志严重等级（默认的过滤设施）或filter对象来决定要对哪些日志进行后续处理；
• 将日志消息传送给所有感兴趣的日志handlers。

2、logger配置方法

• Logger.setLevel() 设置日志器将会处理的日志消息的最低严重级别
• Logger.addHandler() 为该logger对象添加一个handler对象
• Logger.removeHandler() 为该logger对象删除一个handler对象
• Logger.addFilter() 为该logger对象添加一个filter对象
• Logger.removeFilter() 为该logger对象删除一个filter对象

3、创建日志记录

• Logger.debug(), Logger.info(), Logger.warning(), Logger.error(), Logger.critical() 创建一个与它们的方法名对应等级的日志记录
• Logger.exception() 创建一个类似于Logger.error()的日志消息
• Logger.log(level, msg) 需要获取一个明确的日志level参数来创建一个日志记录

4、自己封装一个logger类

# coding=utf-8

import logging


class Log(object):
    def __init__(self, name=__name__, path='mylog.log', level='DEBUG'):
        self.__name = name
        self.__path = path
        self.__level = level
        self.__logger = logging.getLogger(self.__name)
        self.__logger.setLevel(self.__level)

    def __ini_handler(self):
        """初始化handler"""
        stream_handler = logging.StreamHandler()
        file_handler = logging.FileHandler(self.__path, encoding='utf-8')
        return stream_handler, file_handler

    def __set_handler(self, stream_handler, file_handler, level='DEBUG'):
        """设置handler级别并添加到logger收集器"""
        stream_handler.setLevel(level)
        file_handler.setLevel(level)
        self.__logger.addHandler(stream_handler)
        self.__logger.addHandler(file_handler)

    def __set_formatter(self, stream_handler, file_handler):
        """设置日志输出格式"""
        formatter = logging.Formatter('%(asctime)s-%(name)s-%(filename)s-[line:%(lineno)d]'
                                      '-%(levelname)s-[日志信息]: %(message)s',
                                      datefmt='%a, %d %b %Y %H:%M:%S')
        stream_handler.setFormatter(formatter)
        file_handler.setFormatter(formatter)

    def __close_handler(self, stream_handler, file_handler):
        """关闭handler"""
        stream_handler.close()
        file_handler.close()

    @property
    def Logger(self):
        """构造收集器，返回looger"""
        stream_handler, file_handler = self.__ini_handler()
        self.__set_handler(stream_handler, file_handler)
        self.__set_formatter(stream_handler, file_handler)
        self.__close_handler(stream_handler, file_handler)
        return self.__logger


if __name__ == '__main__':
    log = Log(__name__, 'file.log')
    logger = log.Logger
    logger.debug('I am a debug message')
    logger.info('I am a info message')
    logger.warning('I am a warning message')
    logger.error('I am a error message')
    logger.critical('I am a critical message')

Handler类

1、作用

• （基于日志消息的level）将消息分发到handler指定的位置（文件、网络、邮件等）

2、常用handler

• logging.StreamHandler 将日志消息发送到输出到Stream，如std.out, std.err或任何file-like对象
• logging.FileHandler 将日志消息发送到磁盘文件，默认情况下文件大小会无限增长
• logging.handlers.RotatingFileHandler 将日志消息发送到磁盘文件，并支持日志文件按大小切割
• logging.hanlders.TimedRotatingFileHandler 将日志消息发送到磁盘文件，并支持日志文件按时间切割
• logging.handlers.HTTPHandler 将日志消息以GET或POST的方式发送给一个HTTP服务器
• logging.handlers.SMTPHandler 将日志消息发送给一个指定的email地址
• logging.NullHandler 该Handler实例会忽略error messages，通常被想使用logging的开发者使用来避免'No handlers could be found for logger XXX'信息的出现

3、handler配置方法

• handler.setLevel(level) 指定被处理的信息级别，低于lel级别的信息将被忽略
• Handler.setFormatter() 给这个handler设置一个日志格式
• Handler.addFilter(filt) 给这个handler添加一个过滤器
• Handler.removeFilter(filt) 给这个handler删除一个过滤器
  
  

Formatter类

1、作用

• 配置日志信息的格式和内容

2、实例化Formatter类
logging.Formatter(fmt, datefmt, style)

• fmt：指定消息格式化字符串，如果不指定该参数则默认使用message的原始值
• datefmt：指定日期格式字符串，如果不指定该参数则默认使用"%Y-%m-%d %H:%M:%S"
• style：Python 3.2新增的参数，可取值为 '%', '{'和 '$'，如果不指定该参数则默认使用'%'

3、 format格式

字段	使用格式	描述
asctime	%(asctime)s	将日志的时间构造成可读的形式，默认情况下是‘2016-02-08 12:00:00,123’精确到毫秒
name	%(name)s	所使用的日志器名称，默认是'root'，因为默认使用的是rootLogger
filename	%(filename)s	调用日志输出函数的模块的文件名；pathname的文件名部分，包含文件后缀
funcName	%(funcName)s	由哪个function发出的log，调用日志输出函数的函数名
levelname	%(levelname)s	日志的最终等级（被filter修改后的）
message	%(message)s	日志信息，日志记录的文本内容
lineno	%(lineno)d	当前日志的行号，调用日志输出函数的语句所在的代码行
levelno	%(levelno)s	该日志记录的数字形式的日志级别（10, 20, 30, 40, 50）
pathname	%(pathname)s	完整路径，调用日志输出函数的模块的完整路径名，可能没有
process	%(process)s	当前进程，进程ID。可能没有
processName	%(processName)s	进程名称，Python3.1新增
thread	%(thread)s	当前线程，线程ID。可能没有
threadName	%(thread)s	线程名称
module	%(module)s	调用日志输出函数的模块名，filename的名称部分，不包含后缀即不包含文件后缀的文件名
created	%(created)f	当前时间，用UNIX标准的表示时间的浮点数表示，日志事件发生的时间--时间戳，就是当时调用time.time()函数返回的值
relativeCreated	%(relativeCreated)d	输出日志信息时的，自Logger创建以来的毫秒数；日志事件发生的时间相对于logging模块加载时间的相对毫秒数
msecs	%(msecs)d	日志事件发生事件的毫秒部分。logging.basicConfig()中用了参数datefmt，将会去掉asctime中产生的毫秒部分，可以用这个加上

Filter类

后面再补充这块内容
1、作用

• 可以被Handler和Logger用来做比level更细粒度的、更复杂的过滤功能

2、实例化Filter类
Filter是一个过滤器基类，它只允许某个logger层级下的日志事件通过过滤。该类定义如下：

class logging.Filter(name=''):
	filter(record)

一个filter实例化时传递的name参数值为'A.B'，那么该filter实例将只允许名称为类似如下规则的loggers产生的日志记录通过过滤：'A.B'，'A.B,C'，'A.B.C.D'，'A.B.D'，而名称为'A.BB', 'B.A.B'的loggers产生的日志则会被过滤掉。如果name的值为空字符串，则允许所有的日志事件通过过滤。
filter方法用于具体控制传递的record记录是否能通过过滤，如果该方法返回值为0表示不能通过过滤，返回值为非0表示可以通过过滤。
也可以在filter(record)方法内部改变该record，比如添加、删除或修改一些属性。
也可以通过filter做一些统计工作，比如可以计算下被一个特殊的logger或handler所处理的record数量等。

logging默认使用

默认情况下，logging的配置：

• 将日志打印到标准输出中
• 日志级别默认为WARNING(只显示>=WARNING级别的日志)
• 默认输出格式： 日志级别:日志器名称:日志信息

import logging
logging.debug("debug_msg")
logging.info("info_msg")
logging.warning("warning_msg")
logging.error("error_msg")
logging.critical("critical_msg")

"""
WARNING:root:warning_msg
ERROR:root:error_msg
CRITICAL:root:critical_msg
"""

logging简单配置

import logging

logger = logging.getLogger(__name__)    # 实例化logger, 未指定参数时，默认获取一个root logger
logger.setLevel(level=logging.INFO)     # 设置logger日志级别

file_handler = logging.FileHandler('barium.log')    # 设置file_handler类型：输出日志到barium.log文件中
file_handler.setLevel(logging.INFO)          	# 设置file_handler日志级别

console_handler = logging.StreamHandler()	# 设置console_handler类型：输出日志到控制台
console_handler.setLevel(logging.INFO)		# 设置console_handler日志级别

formatter = logging.Formatter('%(levelname)s] %(asctime)s %(threadName)s %(module)s.%(funcName)s[%(lineno)d] %(message)s')  # 设置日志格式formatter

handler.setFormatter(formatter)         # 给handler指定formatter

# 给logger指定handler
logger.addHandler(file_handler)              
logger.addHandler(console_handler) 

logger.info("info msg")			# 打印日志

捕获traceback

Python中的traceback模块被用于跟踪异常返回信息，可以在logging中记录下traceback。
两种方式：

• logger.error(msg, exc_info=True)
• logger.exception(msg)

try:
    raise Exception(ValueError)
except Exception:
    logger.error("value error", exc_info=True)
	
"""
# 捕获了异常，程序正常运行； 同时保留了异常日志信息
ERROR] 2020-04-12 20:34:25,120 MainThread demo.<module>[74] value error
Traceback (most recent call last):
  File "D:/ACZ/barium/util/demo.py", line 72, in <module>
    raise Exception(ValueError)
Exception: <class 'ValueError'>
"""

logging一次性配置

通过logging.basicConfig()进行配置

1. 参数
   • level 指定日志器的日志级别
   • format 指定日志格式字符串，即指定日志输出时所包含的字段信息以及它们的顺序
   • datefmt 指定日期/时间格式。需要注意的是，该选项要在format中包含时间字段%(asctime)s时才有效
   • filename 指定日志输出目标文件的文件名（可以写文件名，则日志放执行文件目录下; 也可以写完整路径，则按照完整路径生成日志文件），指定该设置项后日志信息就不会被输出到控制台
   • filemode 指定日志文件的打开模式，默认为'a' (该选项要在filename指定时才有效)
   • style Python3.2中新添加的配置项。指定format格式字符串的风格，可取值为'%'、'{'和'$'，默认为'%'
   • stream 指定日志输出目标，如sys.stdout、sys.stderr以及网络stream (stream和filename不能同时提供，否则会引发 ValueError异常)
   • handler Python3.3中新添加的配置项。该选项如果被指定，它应该是一个创建了多个Handler的可迭代对象，这些handler将会被添加到root logger中 (filename、stream和handlers这三个配置项只能有一个存在，不能同时出现2个或3个，否则会引发ValueError异常)
     
     

import logging
logging.basicConfig(level=logging.DEBUG,  	# 只输出DEBUG级别以上的日志
                    format="%(asctime)s %(name)s %(levelname)s %(message)s",   # 当style="{"时， 可设置format格式为：format="{asctime}s {name}s {levelname}s {message}s"
                    datefmt='%Y-%m-%d  %H:%M:%S %a',
                    filename=r"d:	est.log"     # 使用filename参数，日志信息不会直接输出显示到控制台，而是直接写入文件
                    )

logging.debug("debug_msg") 
logging.info("info_msg") 
logging.warning("warning_msg")
logging.error("error_msg")
logging.critical("critical_msg")
logging.warning('%s is %d years old.', 'Tom', 10) 

"""
D:	est.log内容：
2020-04-12  16:37:47 Sun root DEBUG debug_msg
2020-04-12  16:37:47 Sun root INFO info_msg
2020-04-12  16:37:47 Sun root WARNING warning_msg
2020-04-12  16:37:47 Sun root ERROR error_msg
2020-04-12  16:37:47 Sun root CRITICAL critical_msg
2020-04-12  16:37:47 Sun root WARNING Tom is 10 years old.
"""

读取配置字典进行配置logging.config.dictConfig()

import logging.config
import os

from util import BARIUM_HOME

log_config = {
    'version': 1,
    'disable_existing_loggers': False,  # 是否禁用现有记录器

    # 日志格式formatter集合(在此自定义了两种日志格式：simple、verbose)
    'formatters': {
        'simple': {
            'format': '%(threadName)s %(module)s.%(funcName)s %(lineno)d %(message)s'
        },
        'verbose':
            {
                'format': '[%(levelname)s] %(asctime)s %(threadName)s %(module)s.%(funcName)s[%(lineno)d] %(message)s'
            },
    },

    # 处理器handler集合
    'handlers': {
        'console': {    # 输出到控制台
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'simple'  # 使用自定义的simple日志格式
        },
        'file': {       # 输出到文件
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': os.path.join(BARIUM_HOME, 'barium.log'),
            'maxBytes': 1024 * 1024 * 5,    # 文件大小 5M
            'encoding': 'utf8',     # 文件编码
            'formatter': 'verbose'  # 使用自定义的verbose日志格式
        },
    },

    # 日志管理器logger集合
    'root': {
        'handlers': ['console', 'file'],
        'level': 'INFO',
        'propagate': False     # 是否传递给父记录器
    }
}


logging.config.dictConfig(log_config)   # 读取配置信息


def get_logger(logger_name=None):	# 获取logger
    """return LOGGER course"""
    return logging.getLogger(logger_name)

LOGGER = get_logger()

LOGGER.info('info msg')			# 打印日志

读取配置文件进行配置logging.config.fileConfig()

配置文件格式基于configparser功能，必须包含[loggers], [handlers]和[formatters], 它们分别代表日志文件中定义的每种类型的实体。

[loggers]
keys=root,log01,log02

[handlers]
keys=hand01, hand02

[formatters]
keys=form01, form02

[logger_root]   #  root logger必须指定一个级别和handlers列表
level=NOTSET    #  DEBUG, INFO, WARNING, ERROR, CRITICAL or NOTSET， 仅对root logger来说，NOTSET表示所有log都会被记录
handlers=hand01

[logger_parser]  	# 非root的logger
level=DEBUG    		# 当level=NOTSET,将通过上一级的logger来确定当前logger的有效级别
handlers=hand01
propagate=1    		# 为1表示message必须传播到上一级logger中，为0表示不传
qualname=compiler.parser   # Logger对象名称

[logger_log01]
handlers = hand01, hand02
qualname = log01
propagate = 0

[handler_hand01]
class=StreamHandler
level=NOTSET  		# NOTSET表示所有log都会被记录
formatter=form01  	# 缺省时,formatter= logging._defaultFormatter;  若formatter指定了该名字，必须在对应的section声明
args=(sys.stdout,)      # args字段是handler类的构造函数的变量列表

[handler_hand02]
class=FileHandler
level=DEBUG
formatter=form01
args=('util/barium.log', 'a')

[formatter_form01]
format=F1 %(asctime)s %(levelname)s %(message)s
datefmt=    				#  datefmt是strftime()兼容的date/time格式字符串，为空时使用默认的ISO8601格式，比如2003-01-23 00:29:50,411
class=logging.Formatter                  #  formatter类名

import logging.config
logging.config.fileConfig('logger.conf')	# 读取配置
logger = logging.getLogger('log01')

logger.info("info msg")				# 打印日志

参考文档：
文档1：https://www.cnblogs.com/du-hong/p/10912692.html
文档2：https://www.cnblogs.com/du-hong/p/10913133.html