Heim  >  Artikel  >  Backend-Entwicklung  >  So verwenden Sie die Loguru-Protokollbibliothek in Python

So verwenden Sie die Loguru-Protokollbibliothek in Python

王林
王林nach vorne
2023-05-01 22:34:052013Durchsuche

1. Übersicht

Die Protokollbibliothek logging in python ist ein bisschen wie log4j, aber die Konfiguration ist normalerweise komplexer, und das ist sie auch Es ist auch schwierig, einen Protokollserver zu erstellen. Der Ersatz für die Standardbibliothek logging ist loguru, der viel einfacher zu verwenden ist. python中的日志库logging使用起来有点像log4j,但配置通常比较复杂,构建日志服务器时也不是方便。标准库logging的替代品是loguruloguru使用起来就简单的多。

loguru默认的输出格式是:时间、级别、模块、行号以及日志内容。loguru不需要手动创建 logger,开箱即用,比logging使用方便得多;另外,日志输出内置了彩色功能,颜色和非颜色控制很方便,更加友好。

loguru是非标准库,需要事先安装,命令是:**pip3 install loguru****。**安装后,最简单的使用样例如下:

from loguru import logger

logger.debug('hello, this debug loguru')
logger.info('hello, this is info loguru')
logger.warning('hello, this is warning loguru')
logger.error('hello, this is error loguru')
logger.critical('hello, this is critical loguru')

上述代码输出:

So verwenden Sie die Loguru-Protokollbibliothek in Python

日志打印到文件的用法也很简单,代码如下:

from loguru import logger

logger.add('myloguru.log')

logger.debug('hello, this debug loguru')
logger.info('hello, this is info loguru')
logger.warning('hello, this is warning loguru')
logger.error('hello, this is error loguru')
logger.critical('hello, this is critical loguru')

上述代码运行时,可以打印到console,也可以打印到文件中去。

So verwenden Sie die Loguru-Protokollbibliothek in Python

2.常见用法

2.1.显示格式

loguru默认格式是时间、级别、名称+模块和日志内容,其中名称+模块是写死的,是当前文件的__name__变量,此变量最好不要修改。

工程比较复杂的情况下,自定义模块名称,是非常有用的,容易定界定位,避免陷入细节中。我们可以通过logger.configure手工指定模块名称。如下如下:

import sys

from loguru import logger

logger.configure(handlers=[
    {
        "sink": sys.stderr,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |<lvl>{level:8}</>| {name} : {module}:{line:4} | <cyan>mymodule</> | - <lvl>{message}</>",
        "colorize": True
    },
])

logger.debug(&#39;this is debug&#39;)
logger.info(&#39;this is info&#39;)
logger.warning(&#39;this is warning&#39;)
logger.error(&#39;this is error&#39;)
logger.critical(&#39;this is critical&#39;)

handlers:表示日志输出句柄或者目的地,sys.stderr表示输出到命令行终端。

"sink": sys.stderr,表示输出到终端

"format":表示日志格式化。<lvl>{level:8}></lvl>表示按照日志级别显示颜色。8表示输出宽度为8个字符。

"colorize": True**:表示显示颜色。

上述代码的输出为:

So verwenden Sie die Loguru-Protokollbibliothek in Python

这里写死了模块名称,每个日志都这样设置也是比较繁琐。下面会介绍指定不同模块名称的方法。

2.2.写入文件

日志一般需要持久化,除了输出到命令行终端外,还需要写入文件。标准日志库可以通过配置文件配置logger,在代码中也可以实现,但过程比较繁琐。loguru相对而已就显得稍微简单一些,我们看下在代码中如何实现此功能。日志代码如下:

import sys

from loguru import logger

logger.configure(handlers=[
    {
        "sink": sys.stderr,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |<lvl>{level:8}</>| {name} : {module}:{line:4} | <cyan>mymodule</> | - <lvl>{message}</>",
        "colorize": True
    },
    {
        "sink": &#39;first.log&#39;,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |{level:8}| {name} : {module}:{line:4} | mymodule | - {message}",
        "colorize": False
    },
])

logger.debug(&#39;this is debug&#39;)
logger.info(&#39;this is info&#39;)
logger.warning(&#39;this is warning&#39;)
logger.error(&#39;this is error&#39;)
logger.critical(&#39;this is critical&#39;)

与2.1.唯一不同的地方,logger.configure新增了一个handler,写入到日志文件中去。用法很简单。

上述只是通过logger.configure设置日志格式,但是模块名不是可变的,实际项目开发中,不同模块写日志,需要指定不同的模块名称。因此,模块名称需要参数化,这样实用性更强。样例代码如下:

import sys

from loguru import logger

logger.configure(handlers=[
    {
        "sink": sys.stderr,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |<lvl>{level:8}</>| {name} : {module}:{line:4} | <cyan>{extra[module_name]}</> | - <lvl>{message}</>",
        "colorize": True
    },
    {
        "sink": &#39;first.log&#39;,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |{level:8}| {name} : {module}:{line:4} | {extra[module_name]} | - {message}",
        "colorize": False
    },
])

log = logger.bind(module_name=&#39;my-loguru&#39;)
log.debug("this is hello, module is my-loguru")

log2 = logger.bind(module_name=&#39;my-loguru2&#39;)
log2.info("this is hello, module is my-loguru2")

logger.bind(module_name='my-loguru')通过bind方法,实现module_name的参数化。bind返回一个日志对象,可以通过此对象进行日志输出,这样就可以实现不同模块的日志格式。

loguru中自定义模块名称的功能比标准日志库有点不同。通过bind方法,可以轻松实现标准日志logging的功能。而且,可以通过bind和logger.configure,轻松实现结构化日志。

上述代码的输出如下:

So verwenden Sie die Loguru-Protokollbibliothek in Python

2.3.json日志

loguru保存成结构化json格式非常简单,只需要设置serialize=True参数即可。代码如下:

from loguru import logger

logger.add(&#39;json.log&#39;, serialize=True, encoding=&#39;utf-8&#39;)
logger.debug(&#39;this is debug message&#39;)
logger.info(&#39;this is info message&#39;)
logger.error(&#39;this is error message&#39;)

输出内容如下:

So verwenden Sie die Loguru-Protokollbibliothek in Python

2.4.日志绕接

loguru日志文件支持三种设置:循环、保留、压缩。设置也比较简单。尤其是压缩格式,支持非常丰富,常见的压缩格式都支持,比如:"gz", "bz2", "xz", "lzma", "tar", "tar.gz", "tar.bz2", "tar.xz", "zip"

loguruDas Standardausgabeformat ist: Zeit, Ebene, Modul, Zeilennummer und Protokollinhalt. loguru muss logger nicht manuell erstellen, es kann sofort verwendet werden, was viel einfacher zu verwenden ist als logging; Die Protokollausgabe verfügt über eine integrierte Farbfunktion. Die Steuerung ohne Farbe ist bequemer und benutzerfreundlicher. 🎜🎜loguru ist eine nicht standardmäßige Bibliothek und muss im Voraus installiert werden. Der Befehl lautet: **pip3 install loguru****. **Nach der Installation lautet das einfachste Anwendungsbeispiel wie folgt: 🎜
from loguru import logger

logger.add("file_1.log", rotation="500 MB")  # 自动循环过大的文件
logger.add("file_2.log", rotation="12:00")  # 每天中午创建新文件
logger.add("file_3.log", rotation="1 week")  # 一旦文件太旧进行循环
logger.add("file_X.log", retention="10 days")  # 定期清理
logger.add("file_Y.log", compression="zip")  # 压缩节省空间
🎜Die obige Codeausgabe: 🎜🎜So verwenden Sie die Loguru-Protokollbibliothek in Python🎜🎜Die Verwendung des Druckens von Protokollen in Dateien ist ebenfalls sehr einfach. Der Code lautet wie folgt: 🎜
logger.add("somefile.log", enqueue=True)
🎜Wenn der obige Code ausgeführt wird, kann dies der Fall sein auf der Konsole oder in einer Datei gedruckt werden. 🎜🎜So verwenden Sie die Loguru-Protokollbibliothek in Python🎜🎜2. Allgemeine Verwendung 🎜

2.1. Anzeigeformat

🎜loguruDas Standardformat ist Zeit, Ebene, Name + Modul und Protokollinhalt, wobei Name + Modul fest codiert ist und das __name__ Variable, ist es am besten, diese Variable nicht zu ändern. 🎜🎜Wenn das Projekt komplexer ist, ist das Anpassen von Modulnamen sehr nützlich. Es ist einfach zu definieren und zu positionieren und verhindert, dass man sich in Details verzettelt. Wir können den Modulnamen manuell über logger.configure angeben. Wie folgt: 🎜
import logging
import logging.handlers
import sys

from loguru import logger

handler = logging.handlers.SysLogHandler(address=(&#39;localhost&#39;, 514))
logger.add(handler)

class LoguruHandler(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=[LoguruHandler()], level=0, format=&#39;%(asctime)s %(filename)s %(levelname)s %(message)s&#39;,
                    datefmt=&#39;%Y-%M-%D %H:%M:%S&#39;)

logger.configure(handlers=[
    {
        "sink": sys.stderr,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |<lvl>{level:8}</>| {name} : {module}:{line:4} | [ModuleA] | - <lvl>{message}</>",
        "colorize": True
    },
])

log = logging.getLogger(&#39;root&#39;)

# 使用标注日志系统输出
log.info(&#39;hello wrold, that is from logging&#39;)
log.debug(&#39;debug hello world, that is from logging&#39;)
log.error(&#39;error hello world, that is from logging&#39;)
log.warning(&#39;warning hello world, that is from logging&#39;)

# 使用loguru系统输出
logger.info(&#39;hello world, that is from loguru&#39;)
🎜handlers: gibt das Protokollausgabe-Handle oder -Ziel an, sys.stderr gibt die Ausgabe an das Befehlszeilenterminal an. 🎜🎜"sink": sys.stderr, bedeutet Ausgabe an das Terminal 🎜🎜"format": bedeutet Protokollformatierung. <lvl>{level:8}></lvl> bedeutet, dass Farben entsprechend der Protokollebene angezeigt werden. 8 bedeutet, dass die Ausgabebreite 8 Zeichen beträgt. 🎜🎜"colorize": True**: Gibt die Anzeigefarbe an. 🎜
🎜Die Ausgabe des obigen Codes ist: 🎜🎜loguru log in Python So verwenden Sie die Bibliothek🎜
🎜Der Modulname ist hier fest codiert und es ist ziemlich umständlich, jedes Protokoll so einzurichten. Im Folgenden wird beschrieben, wie Sie unterschiedliche Modulnamen angeben. 🎜

2.2. Schreiben in Dateien

🎜Protokolle müssen im Allgemeinen nicht nur an das Befehlszeilenterminal ausgegeben werden, sondern auch in Dateien geschrieben werden. Die Standardprotokollbibliothek kann den Logger über die Konfigurationsdatei konfigurieren und kann auch im Code implementiert werden, der Prozess ist jedoch relativ umständlich. Loguru ist relativ einfach. Sehen wir uns an, wie diese Funktion im Code implementiert wird. Der Protokollcode lautet wie folgt: 🎜
# client.py
import pickle
import socket
import struct
import time

from loguru import logger

class SocketHandler:

    def __init__(self, host, port):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((host, port))

    def write(self, message):
        record = message.record
        data = pickle.dumps(record)
        slen = struct.pack(">L", len(data))
        self.sock.send(slen + data)

logger.configure(handlers=[{"sink": SocketHandler(&#39;localhost&#39;, 9999)}])

while True:
    time.sleep(1)
    logger.info("Sending info message from the client")
    logger.debug("Sending debug message from the client")
    logger.error("Sending error message from the client")
🎜Der einzige Unterschied zu 2.1 besteht darin, dass logger.configure einen neuen handler hinzufügt und ihn in die Protokolldatei schreibt. Die Nutzung ist sehr einfach. 🎜
🎜Das Obige legt nur das Protokollformat über logger.configure fest, aber der Modulname ist nicht variabel. In der tatsächlichen Projektentwicklung müssen verschiedene Module beim Schreiben von Protokollen unterschiedliche Modulnamen angeben. Daher müssen Modulnamen parametrisiert werden, um praktischer zu sein. Der Beispielcode lautet wie folgt: 🎜
# server.py
import pickle
import socketserver
import struct

from loguru import logger

class LoggingStreamHandler(socketserver.StreamRequestHandler):

    def handle(self):
        while True:
            chunk = self.connection.recv(4)
            if len(chunk) < 4:
                break
            slen = struct.unpack(&#39;>L&#39;, chunk)[0]
            chunk = self.connection.recv(slen)
            while len(chunk) < slen:
                chunk = chunk + self.connection.recv(slen - len(chunk))
            record = pickle.loads(chunk)
            level, message = record["level"].no, record["message"]
            logger.patch(lambda record: record.update(record)).log(level, message)

server = socketserver.TCPServer((&#39;localhost&#39;, 9999), LoggingStreamHandler)
server.serve_forever()
🎜logger.bind(module_name='my-loguru')Die Parametrisierung von module_name wird durch die Bindungsmethode erreicht. bind gibt ein Protokollobjekt zurück, über das die Protokollausgabe durchgeführt werden kann, sodass Protokollformate für verschiedene Module implementiert werden können. 🎜🎜Die Funktionalität benutzerdefinierter Modulnamen in Loguru unterscheidet sich ein wenig von der Standard-Protokollierungsbibliothek. Durch die Bindungsmethode kann die Funktion des Standardprotokolls logging einfach realisiert werden. Darüber hinaus kann eine strukturierte Protokollierung einfach über bind und logger.configure implementiert werden. 🎜
🎜Die Ausgabe des obigen Codes lautet wie folgt: 🎜🎜 loguru log in Python So verwenden Sie die Bibliothek🎜

2.3.json log

🎜loguru ist sehr einfach im strukturierten JSON-Format zu speichern. Sie müssen nur das serialize=True Parameter Das war’s. Der Code lautet wie folgt: 🎜
# client.py
import zmq
from zmq.log.handlers import PUBHandler
from loguru import logger

socket = zmq.Context().socket(zmq.PUB)
socket.connect("tcp://127.0.0.1:12345")
handler = PUBHandler(socket)logger.add(handler)
logger.info("Logging from client")
🎜Der Ausgabeinhalt lautet wie folgt: 🎜🎜 Wie wäre es mit der Loguru-Protokollbibliothek in Python? Verwenden Sie 🎜

2.4. Log Wrapping

🎜loguru Protokolldateien unterstützen drei Einstellungen: Recycling, Aufbewahrung und Komprimierung. Auch die Einrichtung ist relativ einfach. Insbesondere die Komprimierungsformate sind sehr umfangreich. Es werden gängige Komprimierungsformate unterstützt, wie zum Beispiel: "gz", "bz2", "xz" , "lzma", "tar", "tar.gz", "tar.bz2", "tar.xz", "zip". Der Beispielcode lautet wie folgt: 🎜
from loguru import logger

logger.add("file_1.log", rotation="500 MB")  # 自动循环过大的文件
logger.add("file_2.log", rotation="12:00")  # 每天中午创建新文件
logger.add("file_3.log", rotation="1 week")  # 一旦文件太旧进行循环
logger.add("file_X.log", retention="10 days")  # 定期清理
logger.add("file_Y.log", compression="zip")  # 压缩节省空间

2.5.并发安全

loguru默认是线程安全的,但不是多进程安全的,如果使用了多进程安全,需要添加参数enqueue=True,样例代码如下:

logger.add("somefile.log", enqueue=True)

loguru另外还支持协程,有兴趣可以自行研究。

3.高级用法

3.1.接管标准日志logging

更换日志系统或者设计一套日志系统,比较难的是兼容现有的代码,尤其是第三方库,因为不能因为日志系统的切换,而要去修改这些库的代码,也没有必要。好在loguru可以方便的接管标准的日志系统。

样例代码如下:

import logging
import logging.handlers
import sys

from loguru import logger

handler = logging.handlers.SysLogHandler(address=(&#39;localhost&#39;, 514))
logger.add(handler)

class LoguruHandler(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=[LoguruHandler()], level=0, format=&#39;%(asctime)s %(filename)s %(levelname)s %(message)s&#39;,
                    datefmt=&#39;%Y-%M-%D %H:%M:%S&#39;)

logger.configure(handlers=[
    {
        "sink": sys.stderr,
        "format": "{time:YYYY-MM-DD HH:mm:ss.SSS} |<lvl>{level:8}</>| {name} : {module}:{line:4} | [ModuleA] | - <lvl>{message}</>",
        "colorize": True
    },
])

log = logging.getLogger(&#39;root&#39;)

# 使用标注日志系统输出
log.info(&#39;hello wrold, that is from logging&#39;)
log.debug(&#39;debug hello world, that is from logging&#39;)
log.error(&#39;error hello world, that is from logging&#39;)
log.warning(&#39;warning hello world, that is from logging&#39;)

# 使用loguru系统输出
logger.info(&#39;hello world, that is from loguru&#39;)

输出为:

So verwenden Sie die Loguru-Protokollbibliothek in Python

3.2.输出日志到网络服务器

如果有需要,不同进程的日志,可以输出到同一个日志服务器上,便于日志的统一管理。我们可以利用自定义或者第三方库进行日志服务器和客户端的设置。下面介绍两种日志服务器的用法。

3.2.1.自定义日志服务器

日志客户端段代码如下:

# client.py
import pickle
import socket
import struct
import time

from loguru import logger

class SocketHandler:

    def __init__(self, host, port):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((host, port))

    def write(self, message):
        record = message.record
        data = pickle.dumps(record)
        slen = struct.pack(">L", len(data))
        self.sock.send(slen + data)

logger.configure(handlers=[{"sink": SocketHandler(&#39;localhost&#39;, 9999)}])

while True:
    time.sleep(1)
    logger.info("Sending info message from the client")
    logger.debug("Sending debug message from the client")
    logger.error("Sending error message from the client")

日志服务器代码如下:

# server.py
import pickle
import socketserver
import struct

from loguru import logger

class LoggingStreamHandler(socketserver.StreamRequestHandler):

    def handle(self):
        while True:
            chunk = self.connection.recv(4)
            if len(chunk) < 4:
                break
            slen = struct.unpack(&#39;>L&#39;, chunk)[0]
            chunk = self.connection.recv(slen)
            while len(chunk) < slen:
                chunk = chunk + self.connection.recv(slen - len(chunk))
            record = pickle.loads(chunk)
            level, message = record["level"].no, record["message"]
            logger.patch(lambda record: record.update(record)).log(level, message)

server = socketserver.TCPServer((&#39;localhost&#39;, 9999), LoggingStreamHandler)
server.serve_forever()

运行结果如下:

So verwenden Sie die Loguru-Protokollbibliothek in Python

3.2.2.第三方库日志服务器

日志客户端代码如下:

# client.py
import zmq
from zmq.log.handlers import PUBHandler
from loguru import logger

socket = zmq.Context().socket(zmq.PUB)
socket.connect("tcp://127.0.0.1:12345")
handler = PUBHandler(socket)logger.add(handler)
logger.info("Logging from client")

日志服务器代码如下:

# server.py
import sys
import zmq
from loguru import logger

socket = zmq.Context().socket(zmq.SUB)
socket.bind("tcp://127.0.0.1:12345")
socket.subscribe("")
logger.configure(handlers=[{"sink": sys.stderr, "format": "{message}"}])

while True:
    _, message = socket.recv_multipart()
    logger.info(message.decode("utf8").strip())

3.3.与pytest结合

官方帮助中有一个讲解logurupytest结合的例子,讲得有点含糊不是很清楚。简单的来说,pytest有个fixture,可以捕捉被测方法中的logging日志打印,从而验证打印是否触发。

下面就详细讲述如何使用logurupytest结合的代码,如下:

import pytest
from _pytest.logging import LogCaptureFixture
from loguru import logger

def some_func(i, j):
    logger.info(&#39;Oh no!&#39;)
    logger.info(&#39;haha&#39;)
    return i + j

@pytest.fixture
def caplog(caplog: LogCaptureFixture):
    handler_id = logger.add(caplog.handler, format="{message}")
    yield caplog
    logger.remove(handler_id)

def test_some_func_logs_warning(caplog):
    assert some_func(-1, 3) == 2
    assert "Oh no!" in caplog.text

测试输出如下:

So verwenden Sie die Loguru-Protokollbibliothek in Python

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Loguru-Protokollbibliothek in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme:
Dieser Artikel ist reproduziert unter:yisu.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen