python-日志-logging

python-logging

目录

Python logging 模块定义了为应用程序和库实现灵活的事件日志记录的函数和类。

可以防止频繁的引入print()，Python引入了logging模块来记录我想要的信息

日志包含的信息有正常的程序访问日志还可能有错误、警告等信息输出。

import  logging

logging.debug(msg,*args,**Kwargs)
logging.info(msg,*args,**Kwargs)
logging.warning(msg,*args,**Kwargs)
logging.error(msg,*args,**Kwargs)
logging.critical(msg,*args,**Kwargs)

日志记录函数以它们用来跟踪的事件的级别或严重性

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

关于内建等级级别最低的是DEBUG，级别最高的是CRITICAL。例如setLevel(logging.INFO)，此时函数参数为INFO，那么该logger将只会处理INFO、WARNING、ERROR和CRITICAL级别的日志，而DEBUG级别的消息将会被忽略

通过设置日志级别，可以将高级别的日志分开，单独保存

日志配置

通过 logging.basicConfig() 可以进行简单配置， 可以设置 root 的日志级别，和日志输出格式。

logging.basicConfig()函数是一个一次性的简单配置工具使，也就是说只有在第一次调用该函数时会起作用，后续再次调用该函数时完全不会产生任何操作的

logging.basicConfig()

关键字参数

logging.basicConfig(filename,filemode,format,datefmt,level,stream)
关键字 描述
filename 创建一个 FileHandler，使用指定的文件名，而不是使用 StreamHandler，将日志保存到文件里
filemode 如果指明了文件名，指明打开文件的模式（如果没有指明 filemode，默认为 ‘a’）。
format handler 使用指明的格式化字符串。
datefmt handler 使用指明的格式化字符串。
level 指明根 logger 的级别，默认级别 logging.WARNING
stream 使用指明的流来初始化 StreamHandler。该参数与 ‘filename’ 不兼容，如果两个都有，’stream’ 被忽略。

format 格式

字段/属性名称 使用格式 描述
asctime %(asctime)s 日志事件发生的时间--人类可读时间，如：2003-07-08 16:49:45,896
created %(created)f 日志事件发生的时间--时间戳，就是当时调用time.time()函数返回的值
relativeCreated %(relativeCreated)d 日志事件发生的时间相对于logging模块加载时间的相对毫秒数（目前还不知道干嘛用的）
msecs %(msecs)d 日志事件发生事件的毫秒部分
levelname %(levelname)s 该日志记录的文字形式的日志级别（'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'）
levelno %(levelno)s 该日志记录的数字形式的日志级别（10, 20, 30, 40, 50）
name %(name)s 所使用的日志器名称，默认是'root'，因为默认使用的是 rootLogger
message %(message)s 日志记录的文本内容，通过 msg % args计算得到的
pathname %(pathname)s 调用日志记录函数的源码文件的全路径
filename %(filename)s pathname的文件名部分，包含文件后缀
module %(module)s filename的名称部分，不包含后缀
lineno %(lineno)d 调用日志记录函数的源代码所在的行号
funcName %(funcName)s 调用日志记录函数的函数名
process %(process)d 进程ID
processName %(processName)s 进程名称，Python 3.1新增
thread %(thread)d 线程ID
threadName %(thread)s 线程名称 
import logging
#　打印日志级别
def test():
    logging.basicConfig(level=logging.DEBUG)
    logging.debug('Python debug')
    logging.info('Python info')
    logging.warning('Python warning')
    logging.error('Python Error')
    logging.critical('Python critical')
    logging.log(2,'test')
test()
>>>
DEBUG:root:Python debug
INFO:root:Python info
WARNING:root:Python warning
ERROR:root:Python Error
CRITICAL:root:Python critical

#将日志记录到文件中
logging.basicConfig(filename='F:/example.log', level=logging.DEBUG)
logging.debug('This message should go to the log file')

# 设置显示日期和更改
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')
>>>
2019-10-16 18:57:45,988 is when this event was logged.

线程安全

logging模块不需要调用它的用户再做其他的操作使线程安全，它自己已经实现了线程锁，每一个模块调用的时候是锁定了共享数据区域，每一个handler也对IO进行加锁操作。

四大组件

Logging 模块提供了两种日志记录方式：

  • 一种方式是使用 Logging 提供的模块级别的函数
  • 另一种方式是使用 Logging 日志系统的四大组件记录

Loggers: 可供程序直接调用的接口
Handlers: 决定将日志记录分配至正确的目的地
Filters: 提供更细粒度的日志是否输出的判断
Formatters: 制定最终记录打印的格式布局

组件名称 对应类名 功能描述
日志器 Loggert 提供应用层接口，基于日志记录器和过滤器级别决定哪些日志有效
处理器 Handler 将 logger 创建的日志记录发送到合适的目的输出
过滤器 Filter 提供了更细粒度的控制工具来决定输出哪条日志记录，丢弃哪条日志记录
格式器 Formatter 决定日志记录的最终输出格式

相互关联

  • 日志器（logger）需要通过处理器（handler）将日志信息输出到目标位置，不同的处理器（handler）可以将日志输出到不同的位置；
  • 日志器（logger）可以设置多个处理器（handler）将同一条日志记录输出到不同的位置；
  • 每个处理器（handler）都可以设置自己的过滤器（filter）实现日志过滤，从而只保留感兴趣的日志；
  • 每个处理器（handler）都可以设置自己的格式器（formatter）实现同一条日志以不同的格式输出到不同的地方。

日志器-Logger

Logger类，日志记录器不直接实例化，而是通过模块级函数来进行实例化
使用相同的名称多次调用 getLogger() 总是会返回对相同 Logger 对象的引用

  • 应用程序代码能直接调用日志接口。
  • Logger最常用的操作有两类：配置和发送日志消息。
  • 初始化 logger = logging.getLogger(log_name)获取 logger 对象，最好指定log_name，配置文件和打印日志格式中的 %(name)s 对应的是这里的模块名字，如果不指定name则返回root对象。
  • 设置日志等级 logger.setLevel(logging.DEBUG)，Logging 中有 NOTSET < DEBUG < INFO < WARNING < ERROR < CRITICAL这几种级别，日志会记录设置级别以上的日志
  • 多次使用相同的name调用 getLogger 方法返回同一个 looger 对象；
log=logging.getLogger(logger_name)
#Logger对象最常用的方法分为两类：配置方法 和 消息发送方法
方法 描述
Logger.setLevel() 设置日志器将会处理的日志消息的最低严重级别
Logger.addHandler() 和 Logger.removeHandler() 为该logger对象添加 和 移除一个handler对象
Logger.addFilter() 和 Logger.removeFilter() 为该logger对象添加 和 移除一个filter对象

处理器-Handler

Handler对象的作用是将消息分发到handler指定的位置（文件、网络、邮件等）

需要说明的是，应用程序代码不应该直接实例化和使用Handler实例。因为Handler是一个基类，它只定义了素有handlers都应该有的接口，同时提供了一些子类可以直接使用或覆盖的默认行为

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的library开发者使用来避免'No handlers could be found for logger XXX'信息的出现。 

# 定时循环日志handler，位于logging.handlers，支持定时生成新日志文件。
class logging.handlers.TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False)

参数when决定了时间间隔的类型，参数interval决定了多少的时间间隔。如when=‘D’，interval=2，就是指两天的时间间隔，backupCount决定了能留几个日志文件。超过数量就会丢弃掉老的日志文件。

"""
 'S'         |  秒
 'M'         |  分
 'H'         |  时
 'D'         |  天
 'W0'-'W6'   |  周一至周日
 'midnight'  |  每天的凌晨
 """

 # 添加日志处理器，输出日志到控制台
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.WARN)

过滤器-Filter

class ContextFilter(logging.Filter):

    USERS = ['jim', 'fred', 'sheila']
    IPS = ['123.231.231.123', '127.0.0.1', '192.168.0.1']

    def filter(self, record):
        # record.levelname
        if record.levelname == "DEBUG":
            record.ip = choice(ContextFilter.IPS)
            record.user = choice(ContextFilter.USERS)
            return True
            
# 其中 record 来自 类 LogRecord

关于record 可以得到以下基础信息
record.levelname # record level
record.levelno # record level number
record.msg # record承载的日志消息
record.pathname # emit该日志消息的程序文件
record.lineno # emit该日志消息的程序行号
record.getMessage() # 同record.msg
过滤器案例
import logging

logger = logging.getLogger(__name__)
logger.setLevel(level=logging.INFO)
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
handler.set_name('output-log')
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                              datefmt='%Y/%m/%d %H:%M:%S',
                              style='%')


class MyFilter(logging.Filter):
    def filter(self, record):
        if 'result' in record.msg:
            return False
        return True


handler.setFormatter(formatter)
handler.addFilter(MyFilter('aa'))
logger.addHandler(handler)

try:
    result = 10 / 0
except:
    logger.error('Faild to get result')
    logger.error('Faild')

# 输出： 2019/07/13 20:28:51 - __main__ - ERROR - Faild

格式器-Formatter

一般情况下，它们负责将 LogRecord 转换为可由人或外部系统解释的字符串

logging.Formatter('%(filename)s[line:%(lineno)d] : %(levelname)s~%(asctime)s~%(message)s')

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。
%(processName)s：打印线程名称。
%(module)s：打印模块名称。
%(message)s：打印日志信息。

使用步骤

# 1、新建
log = logging.getLogger('switch')    

#  2、日志等级
log.setLevel(logging.ERROR)

# 3、文件和终端输出，处理器
f_handler = logging.FileHandler('./logdir/switch_opt.log')
c_adndler=logging.StreamHandler()

# 4、格式配置
f_handler.setFormatter(
    logging.Formatter('%(filename)s[line:%(lineno)d] : %(levelname)s~%(asctime)s~%(message)s', OptLogDateTimeFormat))

c_adndler.setFormatter(
    logging.Formatter('%(filename)s[line:%(lineno)d] : %(levelname)s~%(asctime)s~%(message)s', OptLogDateTimeFormat))

# 5、添加处理器
log.addHandler(f_handler)
log.addHandler(c_adndler)

需求案例

1、将高级别的日志单独保存

要求all.log在每天凌晨进行日志切割

需求
1、all.log文件中记录所有的日志信息，日志格式为：日期和时间 - 日志级别 - 日志信息
2、error.log文件中单独记录error及以上级别的日志信息，日志格式为：日期和时间 - 日志级别 - 文件名[:行号] - 日志信息


    
logger = logging.getLogger('mylogger')
logger.setLevel(logging.DEBUG)

rf_handler = logging.handlers.TimedRotatingFileHandler('all.log', when='midnight', interval=1, backupCount=7)
rf_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))

f_handler = logging.FileHandler('error.log')
f_handler.setLevel(logging.ERROR)
f_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(filename)s[:%(lineno)d] - %(message)s"))

logger.addHandler(rf_handler)
logger.addHandler(f_handler)

logger.debug('debug message')
logger.info('info message')
logger.warning('warning message')
logger.error('error message')
logger.critical('critical message')

>>>
all.log文件输出

2021-11-09 10:52:50,649 - DEBUG - debug message
2021-11-09 10:52:50,649 - INFO - info message
2021-11-09 10:52:50,649 - WARNING - warning message
2021-11-09 10:52:50,649 - ERROR - error message
2021-11-09 10:52:50,649 - CRITICAL - critical message

error.log文件输出

2021-11-09 10:52:50,649 - ERROR - testlog.py[:134] - error message
2021-11-09 10:52:50,649 - CRITICAL - testlog.py[:135] - critical message

2、将不同级别的日志分别保存，

使用 dictConfig 进行配置

通过dictConfig配置即可以通过python代码构建一个dict对象，也可以通过yaml、JSON文件来进行配置。字典中必须传入的参数是version，而且目前有效的值也只有1

version: 1
formatters:
  brief:
    format: "%(asctime)s - %(message)s"
  simple:
    format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
handlers:
  console:
    class : logging.StreamHandler
    formatter: brief
    level   : INFO
    stream  : ext://sys.stdout
  file:
    class : logging.FileHandler
    formatter: simple
    level: DEBUG
    filename: debug.log
  error:
    class: logging.handlers.RotatingFileHandler
    level: ERROR
    formatter: simple
    filename: error.log
    maxBytes: 10485760
    backupCount: 20
    encoding: utf8
loggers:
  main.core:
    level: DEBUG
    handlers: [file, error]
root:
  level: DEBUG
  handlers: [console]


import logging.config
from logging import LogRecord


# 通常用于Linux系统下，使控制台输出的日志带颜色
class ColorFormatter(logging.Formatter):
    log_colors = {
        'CRITICAL': '\033[0;31m',
        'ERROR': '\033[0;33m',
        'WARNING': '\033[0;35m',
        'INFO': '\033[0;32m',
        'DEBUG': '\033[0;00m',
    }

    def format(self, record: LogRecord) -> str:
        s = super().format(record)

        level_name = record.levelname
        if level_name in self.log_colors:
            return self.log_colors[level_name] + s + '\033[0m'
        return s


class MyFilter400(logging.Filter):
    def filter(self, record: LogRecord):
        if record.msg.startswith("4"):
            return True
        return False


class MyFilter300(logging.Filter):
    def filter(self, record: LogRecord):
        if record.msg.startswith("3"):
            return True
        return False


LOG_LEVEL = logging.DEBUG

LOGGER = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'color': {
            'class': '__main__.ColorFormatter',  
            # 如果你的模块不是写在启动程序中，请将__main__更换成你模块的路径,下同
            'format': '%(asctime)s [%(name)s] %(levelname)s: %(message)s'
        },
        'default': {
            'class': 'logging.Formatter',
            'format': '%(message)s'
        }
    },
    'filters': {
        'filter_400': {
            '()': '__main__.MyFilter400'
        },
        'filter_300': {
            '()': '__main__.MyFilter300'
        }
    },
    'handlers': {
        'console': {
            'level': LOG_LEVEL,
            'class': 'logging.StreamHandler',
            'formatter': 'color',
        },
        'file1': {
            'level': LOG_LEVEL,
            'class': 'logging.FileHandler',
            'mode': 'w',
            'formatter': 'default',
            'filename': '400_log.txt',
            'encoding': 'utf-8',
            'filters': ['filter_400']
        },
        'file2': {
            'level': LOG_LEVEL,
            'class': 'logging.FileHandler',
            'mode': 'w',
            'formatter': 'default',
            'filename': '300_log.txt',
            'encoding': 'utf-8',
            'filters': ['filter_300']
        },
    },
    'loggers': {
        '__main__': {
            'handlers': ['file1', 'file2', 'console'],
            'level': LOG_LEVEL,
        },
    }
}

# logging.config.dictConfig(LOGGER)
# logger = logging.getLogger(__name__)
#
# logger.debug('200,this is a logger debug message')
# logger.info('302,this is a logger info message')   # 3 开头的写入到300_log.txt
# logger.warning('301,this is a logger warning message')
# logger.error('404,this is a logger error message')   # 4开头的写入到400_log.txt
# logger.critical('500,this is a logger critical message')
#
# print("%s" % __name__)

参考文献

参考文献1、https://www.cnblogs.com/yyds/p/6901864.html

参考文献2：https://blog.csdn.net/qq_35556064/article/details/103995651

参考文献3：https://blog.csdn.net/jeffery0207/article/details/95856490

posted @ 2021-11-09 17:43  贝壳里的星海  阅读(280)  评论(0)  编辑  收藏  举报