Python Logging 模块详解

本文是本人以前的学习笔记，仅供参考

 

日志是一种可以追踪某些软件运行时所发生事件的方法。软件开发人员可以向他们的代码中调用日志记录相关的方法来表明发生了某些事情。一个事件可以用一个可包含可选变量数据的消息来描述。此外，事件也有重要性的概念，这个重要性也可以被称为严重性级别（level）。

1.日志的作用

可以快速的通过日志定位到问题的根源。可见，日志的重要性不可小觑。日志的作用可以简单总结为以下3点：

• 程序调试
• 了解软件程序运行情况，是否正常
• 软件程序运行故障分析与问题定位

如果应用的日志信息足够详细和丰富，还可以用来做用户行为分析，如：分析用户的操作行为、类型洗好、地域分布以及其它更多的信息，由此可以实现改进业务、提高商业利益。

2.日志的等级

默认生成的root logger的level是logging.WARNING,低于该级别的就不输出了

开发应用程序或部署开发环境时，可以使用DEBUG或INFO级别的日志获取尽可能详细的日志信息来进行开发或部署调试；应用上线或部署生产环境时，应该使用WARNING或ERROR或CRITICAL级别的日志来降低机器的I/O压力和提高获取错误日志信息的效率。日志级别的指定通常都是在应用程序的配置文件中进行指定的。

• 上面列表中的日志等级是从上到下依次升高的，即：DEBUG < INFO < WARNING < ERROR < CRITICAL，而日志的信息量是依次减少的；
• 当为某个应用程序指定一个日志级别后，应用程序会记录所有日志级别大于或等于指定日志级别的日志信息，而不是仅仅记录指定级别的日志信息，nginx、php等应用程序以及这里要提高的python的logging模块都是这样的。同样，logging模块也可以指定日志记录器的日志级别，只有级别大于或等于该指定日志级别的日志记录才会被输出，小于该等级的日志记录将会被丢弃。

 

# 如果设置了日志级别为NOTSET,那么这里可以采取debug、info的级别的内容也可以显示在控制台上了
l=logging.NOTSET
logging.debug("this is debug info")
logging.info("this is debug info")
logging.warning("this is debug info")
logging.error("this is debug info")
logging.critical("this is debug")
>>输出
DEBUG:root:this is debug info
INFO:root:this is debug info
WARNING:root:this is debug info
ERROR:root:this is debug info
CRITICAL:root:this is debug info

import logging  # 引入logging模块
logging.basicConfig(level=logging.NOTSET)  # 设置日志级别
logging.debug(u"如果设置了日志级别为NOTSET,那么这里可以采取debug、info的级别的内容也可以显示在控制台上了")

部分名词解释

Logging.Formatter：这个类配置了日志的格式，在里面自定义设置日期和时间，输出日志的时候将会按照设置的格式显示内容。

Logging.Logger：Logger是Logging模块的主体，进行以下三项工作：

1. 为程序提供记录日志的接口

2. 判断日志所处级别，并判断是否要过滤

3. 根据其日志级别将该条日志分发给不同handler

常用函数有：

Logger.setLevel() 设置日志级别

Logger.addHandler() 和 Logger.removeHandler() 添加和删除一个Handler

Logger.addFilter() 添加一个Filter,过滤作用

Logging.Handler：Handler基于日志级别对日志进行分发，如设置为WARNING级别的Handler只会处理WARNING及以上级别的日志。

常用函数有：

setLevel() 设置级别

setFormatter() 设置Formatter

3、日志输出-控制台

import logging  # 引入logging模块
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s')  # logging.basicConfig函数对日志的输出格式及方式做相关配置
# 由于日志基本配置中级别设置为DEBUG，所以一下打印信息将会全部显示在控制台上
logging.info('this is a loggging info message')
logging.debug('this is a loggging debug message')
logging.warning('this is loggging a warning message')
logging.error('this is an loggging error message')
logging.critical('this is a loggging critical message')

4、日志输出-文件

#-8s表示左对齐8个字符
format_string = "%(asctime)s|%(levelname)-8s:%(lineno)d|%(message)s"
date_format = "%Y-%m-%d %H:%M:%S %p"

logging.basicConfig(filename='./logs/demo.log',format=format_string,datefmt=date_format,filemode='w',level=logging.DEBUG)
logging.debug("this is debug info")
logging.info("this is debug info")
logging.warning("this is debug info")
logging.error("this is debug info")
logging.critical("this is debug info")

通过logging.basicConfig函数进行配置了日志级别和日志内容输出格式；因为级别为DEBUG，所以会将DEBUG级别以上的信息都输出显示

import logging
import os.path
import time
# 第一步，创建一个logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)  # Log等级总开关
# 设置显示格式和文件
rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
log_path = os.getcwd()+"/logs/"
log_name = log_path + rq + '.log'
logfile = log_name
# 第二步，创建一个handler，用于写入日志文件
fh = logging.FileHandler(logfile, mode='w',encoding="utf-8")
fh.setLevel(logging.DEBUG)  # 输出到file的log等级的开关
# 第三步，定义handler的输出格式
formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
fh.setFormatter(formatter)
# 第四步，将logger添加到handler里面
logger.addHandler(fh)
# 添加控制台显示的addHandler
ch  = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)

# 日志
logger.debug('this is a logger debug message')
logger.info('this is a logger info message')
logger.warning('this is a logger warning message')
logger.error('this is a logger error message')
logger.critical('this is a logger critical message')

5、日志输出-控制台和文件

只要在输入到日志中的第二步和第三步插入一个handler输出到控制台： 创建一个handler，用于输出到控制台 ch = logging.StreamHandler() ch.setLevel(logging.WARNING) # 输出到console的log等级的开关 第四步和第五步分别加入以下代码即可 ch.setFormatter(formatter) logger.addHandler(ch)

6、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: 打印日志信息

7、捕捉异常,用traceback记录

两种方式：
logger.error('Failed to open file', exc_info=True)
logger.exception("Failed to open file")

如果需要将日志不上报错误，仅记录，可以将exc_info=False

import logging
import os.path
import time
# 第一步，创建一个logger
logger = logging.getLogger()
logger.setLevel(logging.INFO)  # Log等级总开关
# 设置显示格式和文件
rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
log_path = os.getcwd()+"/logs/"
log_name = log_path + rq + '.log'
logfile = log_name
# 第二步，创建一个handler，用于写入日志文件
fh = logging.FileHandler(logfile, mode='w',encoding="utf-8")
fh.setLevel(logging.DEBUG)  # 输出到file的log等级的开关
# 第三步，定义handler的输出格式
formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
fh.setFormatter(formatter)
# 第四步，将logger添加到handler里面
logger.addHandler(fh)
# 添加控制台显示的addHandler
ch  = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)

# 日志

try:
    open('/path/to/does/not/exist', 'rb')
except (SystemExit, KeyboardInterrupt):
    raise
except Exception as e:
    # logger.error('Failed to open file', exc_info=True)
    logger.exception("Failed to open file")

8、多模块调用logging,日志输出顺序

warning_output.py
import logging


def write_warning():
    logging.warning(u"记录文件warning_output.py的日志")

error_output.py

import logging


def write_error():
    logging.error(u"记录文件error_output.py的日志")
main.py
 
import logging
import warning_output
import error_output


def write_critical():
    logging.critical(u"记录文件main.py的日志")


write_critical()
error_output.write_error()
warning_output.write_warning()

从上面来看，日志的输出顺序和模块执行顺序是一致的。

9、日志滚动和过期删除(按时间

 

# coding:utf-8
import logging
import time
import re
from logging.handlers import TimedRotatingFileHandler
from logging.handlers import RotatingFileHandler


def backroll():
    #日志打印格式
    log_fmt = '%(asctime)s\tFile \"%(filename)s\",line %(lineno)s\t%(levelname)s: %(message)s'
    formatter = logging.Formatter(log_fmt)
    #创建TimedRotatingFileHandler对象
    log_file_handler = TimedRotatingFileHandler(filename="ds_update", when="M", interval=2, backupCount=2)
    #log_file_handler.suffix = "%Y-%m-%d_%H-%M.log"
    #log_file_handler.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}.log$")
    log_file_handler.setFormatter(formatter)
    logging.basicConfig(level=logging.INFO)
    log = logging.getLogger()
    log.addHandler(log_file_handler)
    #循环打印日志
    log_content = "test log"
    count = 0
    while count < 30:
        log.error(log_content)
        time.sleep(20)
        count = count + 1
    log.removeHandler(log_file_handler)
if __name__ == "__main__":
    backroll()

filename：日志文件名的prefix；

when：是一个字符串，用于描述滚动周期的基本单位，字符串的值及意义如下： 

“S”: Seconds 

“M”: Minutes 

“H”: Hours 

“D”: Days 

“W”: Week day (0=Monday) 

“midnight”: Roll over at midnight

interval: 滚动周期，单位有when指定，比如：when=’D’,interval=1，表示每天产生一个日志文件

backupCount: 表示日志文件的保留个数

9.两个日志类的实现

实现1

import logging.handlers
from config.config import LOG_PATH
import time
import os

class GetLogger:

    logger = None
    # 获取 logger
    @classmethod
    def get_logger(cls):
        # 如果 logger为空
        if cls.logger is None:
            # 获取日志器
            cls.logger = logging.getLogger()
            # 设置日志器默认级别
            cls.logger.setLevel(logging.INFO)
            # 获取处理器 控制台
            sh = logging.StreamHandler()
            # 获取处理 文件（时间）
            current_time = time.strftime("%Y-%d-%m-%H_%M_%S", time.localtime(time.time()))
            file_name = current_time+".log"
            file_path = os.path.join(LOG_PATH,file_name)
            th = logging.handlers.TimedRotatingFileHandler(filename=file_path,
                                                           when="M",
                                                           interval=1,
                                                           backupCount=2,
                                                           encoding="utf-8")
            # 获取格式器
            fm = "%(asctime)s %(levelname)s [%(name)s] [%(filename)s (%(funcName)s:%(lineno)d] - %(message)s"
            fmt = logging.Formatter(fm)
            # 将格式器 设置 处理器中
            sh.setFormatter(fmt)
            th.setFormatter(fmt)
            # 将处理器 添加到 日志器中
            cls.logger.addHandler(sh)
            cls.logger.addHandler(th)
        # 返回 日志器
        return cls.logger



if __name__ == '__main__':
    # 返回日志实例用来调用
    log = GetLogger().get_logger()
    log.debug("Debug INFO")
    log.info("info INFO")
    log.error("error INFO")
    log.warning("warning INFO")

实现2

import logging
import os
import time

project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # 项目的根路径
log_path = os.path.join(project_path, "logs")  # log的存放路径
if not os.path.exists(log_path): os.mkdir(log_path)  # 不存在log文件夹，则自动创建


class Logger(object):
    default_formats = {
        # 终端输出格式
        'console_fmt': '%(log_color)s%(asctime)s-%(name)s-%(filename)s-[line:%(lineno)d]-%(levelname)s-[日志信息]: %(message)s',
        # 日志输出格式
        'file_fmt': '%(asctime)s-%(filename)s-[line:%(lineno)d]-%(levelname)s-[日志信息]: %(message)s'
    }

    def __init__(self, name=None, log_level=logging.DEBUG):
        self.name = name
        # ①创建一个记录器
        self.logger = logging.getLogger(self.name)
        self.logger.setLevel("INFO")  # 设置日志级别为 'level'，即只有日志级别大于等于'level'的日志才会输出
        self.log_formatter = logging.Formatter(self.default_formats["file_fmt"])  # 创建formatter
        self.console_formatter = logging.Formatter(self.default_formats["file_fmt"])  # 创建formatter
        # ②创建屏幕-输出到控制台，设置输出等级
        self.streamHandler = logging.StreamHandler()
        self.streamHandler.setLevel("DEBUG")
        # ③创建log文件，设置输出等级
        time_now = time.strftime('%Y_%m%d_%H', time.localtime()) + '.log'  # log文件命名：2022_0402_21.log
        self.fileHandler = logging.FileHandler(os.path.join(log_path, time_now), 'a', encoding='utf-8')
        self.fileHandler.setLevel("DEBUG")
        # ④用formatter渲染这两个Handler
        self.streamHandler.setFormatter(self.console_formatter)
        self.fileHandler.setFormatter(self.log_formatter)
        # ⑤将这两个Handler加入logger内
        if not self.logger.handlers:  # 在新增handler时判断是否为空,解决log重复打印的问题
            self.logger.addHandler(self.streamHandler)
            self.logger.addHandler(self.fileHandler)

    def getLogger(self):
        return self.logger


logger = Logger().getLogger()

if __name__ == '__main__':
    logger = Logger().getLogger()
    logger.warning("warning")
    logger.error("error")
    logger.info("info")
    logger.debug("debug")
    logger.critical("critical")