python日志记录loguru以及如何记录到两个日志文件中

在部署一些定时运行或者长期运行的任务时，为了留存一些导致程序出现异常或错误的信息，通常会才用日志的方式来进行记录这些信息。

在 Python 中用到日志记录，那就不可避免地会用到内置的 logging标准库 。虽然logging 库采用的是模块化设计，你可以设置不同的 handler 来进行组合，但是在配置上通常较为繁琐；而且如果不是特别处理，在一些多线程或多进程的场景下使用 logging还会导致日志记录会出现错乱或是丢失的情况。

但有这么一个库，它不仅能够减少繁琐的配置过程还能实现和logging类似的功能，同时还能保证日志记录的线程进程安全，又能够和logging 相兼容，并进一步追踪异常也能进行代码回溯。这个库叫loguru——一个专为像我这样懒人而生日志记录库。

loguru 库的使用可以说是十分简单，我们直接可以通过导入它本身封装好的logger 类就可以直接进行调用。

#!pip install loguru
from loguru import logger

logger 本身就是一个已经实例化好的对象，如果没有特殊的配置需求，那么自身就已经带有通用的配置参数；同时它的用法和 logging库输出日志时的用法一致

In [1]: from loguru import logger 
   ...:  
   ...: logger.debug("debug message"    ) 
   ...: logger.info("info level message") 
   ...: logger.warning("warning level message") 
   ...: logger.critical("critical level message")                                                                                                                                               
2020-10-07 14:23:09.637 | DEBUG    | __main__:<module>:3 - debug message
2020-10-07 14:23:09.637 | INFO     | __main__:<module>:4 - info level message
2020-10-07 14:23:09.638 | WARNING  | __main__:<module>:5 - warning level message
2020-10-07 14:23:09.638 | CRITICAL | __main__:<module>:6 - critical level message

当你在IDE 或终端里运行时会发现，loguru 还为输出的日志信息带上了不同的颜色样式（schema），使得结果更加美观。

当然，loguru 也像logging一样为我们提供了其他可配置的部分，但相比于 logging 每次要导入特定的handler再设定一些formatter来说是更为「傻瓜化」了。

配置

使用基本的add() 方法就可以对logger 进行简单的配置，这些配置有点类似于使用 logging 时的 handler。这里简单提及一下比较常用的几个。

写入日志

在不指定任何参数时，logger 默认采用sys.stderr标准错误输出将日志输出到控制台（console）中；但在linux服务器上我们有时不仅让其输出，还要以文件的形式进行留存，那么只需要在第一个参数中传入一个你想要留存文件的路径字符串即可。就像这样：

from loguru import logger
import os

logger.add(os.path.expanduser("~/Desktop/testlog.log"))
logger.info("hello, world!")

这样在你的桌面上就会直接出现相应的testlog.log日志文件了。

但是如果你没有自己要是用logging没有预先封装来操作，那估计你得写成这样：

import logging
import os
import sys
from logging import handlers

log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
fmt = logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
LOGFILE = os.path.expanduser("~/Desktop/testlog.log")

console_handler = logging.StreamHandler(sys.stderr)
console_handler.setFormatter(fmt)
log.addHandler(console_handler)

file_handler = handlers.RotatingFileHandler(LOGFILE)
file_handler.setFormatter(fmt)
log.addHandler(file_handler)

log.info("hello, world")

其中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
    ):
    pass

sink

另外我们还注意到它有个非常重要的参数 sink，我们看看官方文档：https://loguru.readthedocs.io/en/stable/api/logger.html#sink，可以了解到通过 sink 我们可以传入多种不同的数据结构，汇总如下：

•sink 可以传入一个 file 对象，例如 sys.stderr 或者 open(‘file.log’, ‘w’) 都可以。

•sink 可以直接传入一个 str 字符串或者 pathlib.Path 对象，其实就是代表文件路径的，如果识别到是这种类型，它会自动创建对应路径的日志文件并将日志输出进去。

•sink 可以是一个方法，可以自行定义输出实现。

•sink 可以是一个 logging 模块的 Handler，比如 FileHandler、StreamHandler 等等，或者上文中我们提到的 CMRESHandler 照样也是可以的，这样就可以实现自定义 Handler 的配置。

•sink 还可以是一个自定义的类，具体的实现规范可以参见官方文档。

所以说，刚才我们所演示的输出到文件，仅仅给它传了一个 str 字符串路径，他就给我们创建了一个日志文件，就是这个原理。

format、filter、level

下面我们再了解下它的其他参数，例如format、filter、level等等。

其实它们的概念和格式和 logging 模块都是基本一样的了，例如这里使用 format、filter、level 来规定输出的格式：

logger.add('runtime.log', format="{time} {level} {message}", filter="my_module", level="INFO")

如何记录到两个日志文件中

这里是根据filter来进行区分logger的，再用logger.bind()来做logger的区分。

logger.add("../static/logs/a.log", filter=lambda record: record["extra"]["name"] == "service_log")
logger.add("../static/logs/b.log", filter=lambda record: record["extra"]["name"] == "app_log")

# 这个bind()函数就是在extra里额外增加键值
logger_a = logger.bind(name="service_log")
logger_b = logger.bind(name="app_log")


logger_a.info("Message A")
logger_b.info("Message B")

按照日志等级记录到不同文件中

logger.add(path_log_info, level="INFO",filter=lambda x: 'INFO' in str(x['level']).upper())
logger.add(path_log_error, level="INFO",filter=lambda x: 'ERROR' in str(x['level']).upper())

删除 sink

另外添加 sink 之后我们也可以对其进行删除，相当于重新刷新并写入新的内容。

删除的时候根据刚刚 add 方法返回的 id 进行删除即可，看下面的例子：

from loguru import logger

trace = logger.add('runtime.log')
logger.debug('this is a debug message')
logger.remove(trace)
logger.debug('this is another debug message')

看这里，我们首先 add 了一个 sink，然后获取它的返回值，赋值为 trace。随后输出了一条日志，然后将 trace 变量传给 remove 方法，再次输出一条日志，看看结果是怎样的。

控制台输出如下：

2020-04-12 23:18:26.469 | DEBUG    | __main__::4 - this is a debug message
2020-04-12 23:18:26.469 | DEBUG    | __main__::6 - this is another debug message

日志文件 runtime.log 内容如下：

2020-04-12 23:18:26.469 | DEBUG    | __main__::4 - this is a debug message

可以发现，在调用 remove 方法之后，确实将历史 log 删除了。

这样我们就可以实现日志的刷新重新写入操作。

日志留存、压缩与清理(rotation 、compression 和retention)

通常来说如果程序或服务的量级较大，那么就可以通过集成的日志平台或数据库来对日志信息进行存储和留存，后续有需要的话也方便进行日志分析。

但对我们个人或者一些中小型项目来说，通常只需要以文件的形式留存输出的日志即可。

尽管我们需要将日志写入到相应的文件中，如果是少量的日志那还好，但是如果是日志输出或记录时间较长的情况，那么单个日志文件就十分之大，倘若仍然是将日志都写入到一个文件中，那么当日志中的内容增长到一定数量时我们想要读取并查找相应的部分时就十分困难。这时候我们就需要对日志文件进行留存、压缩，甚至在必要时及时进行清理。

基于以上，我们可以通过对rotation 、compression 和retention 三个参数进行设定来满足我们的需要：

rotation 参数能够帮助我们将日志记录以大小、时间等方式进行分割或划分：

mport os
from loguru import logger

LOG_DIR = os.path.expanduser("~/Desktop/logs")
LOG_FILE = os.path.join(LOG_DIR, "file_{time}.log")
if os.path.exits(LOG_DIR):
    os.mkdir(LOG_DIR)

logger.add(LOG_FILE, rotation = "200KB")
for n in range(10000):
    logger.info(f"test - {n}")

最后呈现如下：

rotation可选参数如下

'0:00'
'1 day'
'1 week'
'12:00'
"100 MB", "0.5 GB", "1 month 2 weeks", "4 days", "10h",
"monthly", "18:00", "sunday", "w0", "monday at 12:00"

随着分割文件的数量越来越多之后，我们也可以进行压缩对日志进行留存，这里就要使用到 compression参数，该参数只要你传入通用的压缩文件扩展名即可，如zip、tar、gz等。

import os
from loguru import logger

LOG_DIR = os.path.expanduser("~/Desktop/logs")
LOG_FILE = os.path.join(LOG_DIR, "file_{time}.log")
if os.path.exits(LOG_DIR):
    os.mkdir(LOG_DIR)

logger.add(LOG_FILE, rotation = "200KB", compression="zip")
for n in range(10000):
    logger.info(f"test - {n}")

从结果可以看到，只要是满足了rotation分割后的日志文件都被直接压缩成了zip 文件，文件大小由原本的 200kb 直接减少至10kb，对于一些磁盘空间吃紧的Linux服务器来说是则是很有必要的。

也可以选择成压缩为别的格式

"gz", "bz2", "xz", "lzma", "tar", "tar.gz", "tar.bz2",
  "tar.xz", "zip"

当然了，如果你不想对日志进行留存，或者只想保留一段时间内的日志并对超期的日志进行删除，那么直接使用retention参数就好了。

这里我们可以将之前的结果随意复制 N 多份在logs文件夹中，然后再执行一次加上retension参数后代码：

from loguru import logger

LOG_DIR = os.path.expanduser("~/Desktop/logs")
LOG_FILE = os.path.join(LOG_DIR, "file_{time}.log")
if not os.path.exists(LOG_DIR):
    os.mkdir(LOG_DIR)

logger.add(LOG_FILE, rotation="200KB",retention=1)
for n in range(10000):
    logger.info(f"test - {n}")

比如我们想要设置日志文件最长保留 10 天，可以这么来配置：

logger.add('runtime.log', retention='10 days')

其他可选值是

"1 week",  "3 days", "2 months"

当然对retention传入整数时，该参数表示的是所有文件的索引，而非要保留的文件数，这里是个反直觉的小坑，用的时候注意一下就好了。所以最后我们会看到只有两个时间最近的日志文件会被保留下来，其他都被直接清理掉了。

序列化(serialize)

如果在实际中你不太喜欢以文件的形式保留日志，那么你也可以通过serialize参数将其转化成序列化的json格式，最后将导入类似于MongoDB、ElasticSearch 这类数NoSQL数据库中用作后续的日志分析。

from loguru import logger
import os

logger.add(os.path.expanduser("~/Desktop/testlog.log"), serialize=True)
logger.info("hello, world!")

最后保存的日志都是序列化后的单条记录：

{
    "text": "2020-10-07 18:23:36.902 | INFO     | __main__::6 - hello, world\n",
    "record": {
        "elapsed": {
            "repr": "0:00:00.005412",
            "seconds": 0.005412
        },
        "exception": null,
        "extra": {},
        "file": {
            "name": "log_test.py",
            "path": "/Users/Bobot/PycharmProjects/docs-python/src/loguru/log_test.py"
        },
        "function": "",
        "level": {
            "icon": "\u2139\ufe0f",
            "name": "INFO",
            "no": 20
        },
        "line": 6,
        "message": "hello, world",
        "module": "log_test",
        "name": "__main__",
        "process": {
            "id": 12662,
            "name": "MainProcess"
        },
        "thread": {
            "id": 4578131392,
            "name": "MainThread"
        },
        "time": {
            "repr": "2020-10-07 18:23:36.902358+08:00",
            "timestamp": 1602066216.902358
        }
    }
}

异常追溯(backtrace和diagnose)

当异常和错误不可避免时，最好的方式就是让我们知道程序到底是哪里出了错，或者是因为什么导致错误，这样才能更好地让开发人员及时应对并解决。

loguru集成了一个名为better_exceptions的库，不仅能够将异常和错误记录，并且还能对异常进行追溯，这里是来自一个官网的例子

import os
import sys

from loguru import logger

logger.add(os.path.expanduser("~/Desktop/exception_log.log"), backtrace=True, diagnose=True)

def func(a, b):
    return a / b

def nested(c):
    try:
        func(5, c)
    except ZeroDivisionError:
        logger.exception("What?!")

if __name__ == "__main__":
    nested(0)

最后在日志文件中我们可以得到以下内容：

File "/Users/Bobot/PycharmProjects/docs-python/src/loguru/log_test.py", line 20, in 
    nested(0)
    └ 

> File "/Users/Bobot/PycharmProjects/docs-python/src/loguru/log_test.py", line 14, in nested
    func(5, c)
    │       └ 0
    └ 

  File "/Users/Bobot/PycharmProjects/docs-python/src/loguru/log_test.py", line 10, in func
    return a / b
           │   └ 0
           └ 5

ZeroDivisionError: division by zero

与 Logging 完全兼容

尽管说loguru 算是重新「造轮子」，但是它也能和logging库很好地兼容。到现在我们才谈论到add()方法的第一个参数sink。

这个参数的英文单词动词有「下沉、浸没」等意，对于外国人来说在理解上可能没什么难的，可对我们国人来说，这可之前logging 库中的handler 概念还不好理解。好在前面我有说过，loguru 和logging 库的使用上存在相似之处，因此在后续的使用中其实我们就可以将其理解为handler，只不过它的范围更广一些，可以除了handler之外的字符串、可调用方法、协程对象等。

loguru 官方文档对这一参数的解释是：

object in charge of receiving formatted logging messages and propagating them to an appropriate endpoint.

翻译过来就是「一个用于接收格式化日志信息并将其传输合适端点的对象」，进一步形象理解就像是一个「分流器」。

import logging.handlers
import os
import sys

from loguru import logger

LOG_FILE = os.path.expanduser("~/Desktop/testlog.log")
file_handler = logging.handlers.RotatingFileHandler(LOG_FILE, encoding="utf-8")
logger.add(file_handler)
logger.debug("hello, world")

当然目前只是想在之前基于logging 写好的模块中集成loguru，只要重新编写一个继承自 logging.Handler类并实现了emit()方法的Handler即可。

import logging.handlers
import os
import sys

from loguru import logger

class InterceptHandler(logging.Handler):
    def emit(self, record):
        try:
            level = logger.level(record.levelname).name
        except ValueError:
            level = record.levelno

        frame, depth = logging.currentframe(), 2
        while frame.f_code.co_filename == logging.__file__:
            frame = frame.f_back
            depth += 1

        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())

logging.basicConfig(handlers=[InterceptHandler()], level=0)

def func(a, b):
    return a / b

def nested(c):
    try:
        func(5, c)
    except ZeroDivisionError:
        logging.exception("What?!")

if __name__ == "__main__":
    nested(0)

后结果同之前的异常追溯一致。而我们只需要在配置后直接调用logging 的相关方法即可，减少了迁移和重写的成本。

最后

本文介绍了关于loguru的常用方法，从对比例子上来看，相比于复杂的 logging 配置来说，使用loguru 库无疑还是很香的，毕竟别人已经为我们一些日常的通用性需求提供了封装好的解决方案，无论是在学习还是在使用的成本上，无疑还是比较小的。

由于篇幅有限，loguru的其他配置部分没有进一步展开，如果看完本文的你对这个库感兴趣并打算投入到实际的开发和生产中使用，那么建议你还是阅读一下其官方文档，有必要的话可以浏览一下源码。

不过loguru的通用配置不一定满足每个人的需要，对于那些动手能力强或水平较高的朋友还能进一步根据个人需求或业务需求进行二次封装，或许也能较为贴合实际情况。