logging

logging是Python自带的日志标准库

需求：同时将日志输出到控制台及写入文件

编写工具类

utils/log.py

import logging
import os
# 1. 创建一个logger
logger = logging.getLogger('simple_example')
logger.setLevel(logging.DEBUG)  # Log等级总开关
# 2.控制台的handler
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# 3. 写入文件的handler
root_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
fh = logging.FileHandler(filename=os.path.join(root_dir, 'log/run.log'), encoding='utf-8')
# 4. 定义handler的输出格式
format ='%(asctime)s - %(filename)s - %(lineno)d - %(name)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(fmt=format)
ch.setFormatter(formatter)
fh.setFormatter(formatter)
# 将logger添加到handler里面
logger.addHandler(ch)
logger.addHandler(fh)

Formatter格式化有以下参数

    %(name)s            Name of the logger (logging channel)
    %(levelno)s            打印日志级别的数值
    %(levelname)s       打印日志级别的名称
    %(pathname)s        打印当前执行程序的路径，其实就是 sys.argv [0]
    %(filename)s        打印当前执行程序名
    %(module)s          打印当前模块名
    %(lineno)d          打印日志的当前行号
    %(funcName)s        Function name
    %(created)f         Time when the LogRecord was created (time.time()
                        return value)
    %(asctime)s         Textual time when the LogRecord was created
    %(msecs)d           Millisecond portion of the creation time
    %(relativeCreated)d Time in milliseconds when the LogRecord was created,
                        relative to the time the logging module was loaded
                        (typically at application startup time)
    %(thread)d          Thread ID (if available)
    %(threadName)s      Thread name (if available)
    %(process)d         Process ID (if available)
    %(message)s         The result of record.getMessage(), computed just as
                        the record is emitted

使用

要在别的文件中中使用from utils.log import logger

import pymysql
from utils.log import logger
if __name__ == '__main__':
    try:
        # 创建连接对象
        db = pymysql.connect(host='localhost',
                             user='root',
                             passwd='',
                             db='ehsy',  # 数据库名字
                             port=3306,
                             autocommit=True, # 指定 autocommit 为 True
                             charset='utf8')
        # 创建游标对象
        # pymysql.cursors.DictCursor 以字典的形式返回查询出来的数据
        cursor = db.cursor(pymysql.cursors.DictCursor)
    except Exception as e:
        logger.error('数据库连接失败{}'.format(e))

控制台输出：

日志文件写入：

2022-05-24 14:18:58,825 - logging_use2.py - 18 - simple_example - ERROR - 数据库连接失败(2003, "Can't connect to MySQL server on 'localhost' ([WinError 10061] 由于目标计算机积极拒绝，无法连接。)")

Loguru

Loguru是一个旨在为Python带来愉快日志记录的第三方库。更加优雅、高效、简洁的

安装

Loguru 仅支持 Python 3.5 及以上的版本，使用 pip 安装即可：

pip install loguru

简单使用

from loguru import logger
logger.info("This is log info!")
logger.warning("This is log warn!")
logger.error("This is log error!")
logger.debug("This is log debug!")

控制台输出：

add()函数

与 logging 模块不同，要想自定义日志级别以及格式，不需要 Handler，不需要 Formatter，只需要一个 add() 函数就可以， add() 语句的详细参数：

    def add(
        self,
        sink,
        *,
        level=_defaults.LOGURU_LEVEL,
        format=_defaults.LOGURU_FORMAT,
        filter=_defaults.LOGURU_FILTER,
        colorize=_defaults.LOGURU_COLORIZE,
        serialize=_defaults.LOGURU_SERIALIZE,
        backtrace=_defaults.LOGURU_BACKTRACE,
        diagnose=_defaults.LOGURU_DIAGNOSE,
        enqueue=_defaults.LOGURU_ENQUEUE,
        catch=_defaults.LOGURU_CATCH,
        **kwargs
    ):

参数讲解：
https://loguru.readthedocs.io/en/stable/api/logger.html
https://segmentfault.com/a/1190000040911280

将日志输出到文件

from loguru import logger
import os
root_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
filename =os.path.join(root_dir, 'log/run.log')
logger.add(filename)
logger.info('this is a info')

rotation 日志文件分隔

设置超过 500 MB 新创建一个 log 文件：

from loguru import logger
logger.add('run_{time}.log', rotation="500 MB")
logger.info('this is a info')

通过这样的配置我们就可以实现每 500MB 存储一个文件，每个 log 文件过大就会新创建一个 log 文件。我们在配置 log 名字时加上了一个 time 占位符，这样在生成时可以自动将时间替换进去，生成一个文件名包含时间的 log 文件。

设置每隔一个周新创建一个 log 文件：

logger.add('runtime_{time}.log', rotation='1 week')

retention 配置

很多情况下，一些非常久远的 log 对我们来说并没有什么用处了，它白白占据了一些存储空间，不清除掉就会非常浪费。retention 这个参数可以配置日志的最长保留时间。
比如我们想要设置日志文件最长保留 10 天，可以这么来配置：

logger.add('run.log', retention='10 days')
#可以传入 Examples: "1 week, 3 days", "2 months"

设置日志文件最多保留 10 个：

logger.add('runtime_{time}.log', retention=10)

也可以是一个 datetime.timedelta 对象，比如设置日志文件最多保留 5 个小时：

import datetime
from loguru import logger
logger.add('runtime_{time}.log', retention=datetime.timedelta(hours=5))

compression 日志压缩格式

add() 函数的 compression 参数，可以配置日志文件的压缩格式，这样可以更加节省存储空间，比如设置使用 zip 文件格式保存：

logger.add('runtime_{time}.log', compression='zip')

其格式支持：gz、bz2、xz、lzma、tar、tar.gz、tar.bz2、tar.xz

封装成工具类

如果我们要在多个模块中都使用loguru，将日志写入，我们需要多次设置logger.add( ),没办法一次性设置后，多次使用，这是我们可以封装成工具类
utils/Loggings.py

import os
from loguru import logger
class Loggings:
    root_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
    filename = os.path.join(root_dir, 'log/run.log')
    __instance = None
    logger.add(
        sink=filename,  # 写入文件路径
        rotation="500MB",
        encoding="utf-8",
        enqueue=True,
        retention="10 days"
    )
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(Loggings, cls).__new__(cls, *args, **kwargs)
        return cls.__instance
    def info(self, msg):
        return logger.info(msg)
    def debug(self, msg):
        return logger.debug(msg)
    def warning(self, msg):
        return logger.warning(msg)
    def error(self, msg):
        return logger.error(msg)

调用：

from utils.Loggings import Loggings
log = Loggings()
log.info('this is a info')