Dies ist eine Einführung in die Bibliothek für die Protokollausgabe von Python. Einführung in drei Arten von Beispielcode und deren Verwendung: Bibliotheken logzero, loguru und pyrogrus, mit denen die Protokollausgabe einfacher und bequemer verwaltet werden kann als mit der Standardprotokollierung.

Beispielcode

Wir haben Beispielcode für jede Bibliothek vorbereitet. Bitte beziehen Sie sich zusammen mit der später beschriebenen Verwendung darauf.

logzero

Dokumentation: https://github.com/metachris/logzero, https://logzero.readthedocs.io/en/latest/

Eine Bibliothek, die anstelle der Protokollierung verwendet werden kann. Eine benutzerfreundliche Version der Protokollierung.

Verwendung von logzero

Mit Standardeinstellungen verwenden

from logzero import logger

logger.trace("sample trace level log message")
logger.debug("sample debug level log message")
logger.info("sample info level log message")
logger.warning("sample warn level log message")
logger.error("sample error level log message")
logger.critical("sample critical level log message")

Einstellung der Konsolenausgabeprotokollebene

logzero.loglevel(logging.INFO)

Einstellungen für die Protokolldateiausgabe

#Ausgabeeinstellungen
logzero.logfile(
    '/var/log/logzero.log',  #Protokolldateipfad
    loglevel=logging.ERROR,   #Ausgabe auf Protokollebene in Datei
    maxBytes=1e6,            #maximale Dateigröße
    backupCount=3            #Anzahl der Generationen alter Dateien, die aufbewahrt werden sollen
)

#Ausgabeeinstellungen deaktivieren
logzero.logfile(None)

Protokollformat

Der Teil von "% (Farbe) s" bis "% (end_color) s" wird entsprechend der Protokollstufe gefärbt.

log_format = '%(color)s[%(levelname)1.1s %(asctime)s %(name)s %(module)s %(funcName)s:%(lineno)d]%(end_color)s %(message)s'
formatter = logzero.LogFormatter(fmt=log_format)
logzero.formatter(formatter)

Erstellen einer Logger-Instanz

#Erstellen einer Logger-Instanz
log_format = '%(color)s[%(levelname)1.1s %(asctime)s %(name)s %(module)s %(funcName)s:%(lineno)d]%(end_color)s %(message)s'
formatter = logzero.LogFormatter(fmt=log_format)
custom_logger = logzero.setup_logger(
    name=__name__,
    logfile="/var/log/logzero.log",
    formatter=formatter,
    maxBytes=1000000,
    backupCount=3,
    level=logging.INFO,
    fileLoglevel=logging.ERROR,
    disableStderrLogger=False,
)

#Protokollausgabe
custom_logger.debug("sample class custom logger debug level log message")
custom_logger.info("sample class custom logger info level log message")
custom_logger.warning("sample class custom logger warn level log message")
custom_logger.error("sample class custom logger error level log message")

loguru

Dokumentation: https://github.com/Delgan/loguru, https://loguru.readthedocs.io/en/stable/index.html

Es unterscheidet sich von der Protokollierung, ist jedoch einfach und intuitiv zu bedienen.

Wie benutzt man Loguru?

Protokollausgabeziel hinzufügen

Standardmäßig wird es nur an stderr ausgegeben. Wenn Sie auch in eine Datei ausgeben möchten, führen Sie logger.add wie folgt aus.

logger.add("/var/log/loguru_sample2.log")

Einstellungen wie Protokollrotation

logger.add("file_1.log", rotation="500 MB")    #Drehung nach Dateigröße
logger.add("file_2.log", rotation="12:00")     #Tägliche Rotation zur festgelegten Zeit
logger.add("file_3.log", rotation="1 week")    #Wöchentliche Rotation
logger.add("file_A.log", retention=3)  #Halte 3 Generationen
logger.add("file_B.log", retention="10 days")  #10 Tage halten
logger.add("file_Y.log", compression="zip")    #Mit Reißverschluss komprimieren

Weitere Einstellungen finden Sie unter https://loguru.readthedocs.io/en/stable/api/logger.html#file. Diese logger.add hat einige konfigurierbare Parameter wie die Log-Ebene. Weitere Informationen finden Sie unter https://loguru.readthedocs.io/en/stable/api/logger.html?highlight=logger.add#loguru._logger.Logger.add. * Es wird empfohlen, False für Diagnose und Rückverfolgung festzulegen.

Beispiel für logger.add

logger.add(
    "/var/log/sample.log",
    rotation="12:00",
    format=log_format,
    diagnose=False,
    backtrace=False,
    level=LOG_LEVEL
)

Formatierung

Sie können das Protokoll einfärben, indem Sie es als "<grün> ～～～ </ grün>" schreiben. Sie können die Farbe je nach Schweregrad mit ändern. Protokollnachrichten sind dem Datensatz zugeordnet. record ist ein Wörterbuchtyp und wird durch Einbetten des Schlüssels in das Format "{message}" eingebettet Es kann in das Protokoll eingebettet werden. Was für einen Schlüssel hast du? https://loguru.readthedocs.io/en/stable/api/logger.html Siehe "Das Aufnahmediktat" in.

log_format = "<green>{time:YYYY-MM-DDTHH:mm:ss}</green> <level>{level} {message}</level>"

#Wenn Sie die Konsolenausgabe einstellen möchten, müssen Sie zuerst die Standardeinstellung deaktivieren.
#Zuvor Logger.Beachten Sie, dass der hinzugefügte ebenfalls verschwindet.
logger.remove()
logger.add(sys.stderr, format=log_format)

Fügen Sie dem Format einen Wert hinzu, der nicht im Datensatz enthalten ist

Sie können es als zusätzliches Diktat im Format definieren, z. B. "{extra [extra_value]}", und es als Bindungs- oder Nachrichtenargument übergeben.

logger.remove()
log_format = "<green>{time}</green>: <level>{level} {message}</level>: {extra[extra_value]}"
logger.add(
    sys.stdout,
    format=log_format,
    serialize=True
)

logger.bind(extra_value="some_extra_value").info("serialize message 01")
logger.info("serialize message 02", extra_value="some_extra_value")

Ausgabe in JSON

Die Ausgabe kann json als "serialize = True" sein.

logger.remove()
log_format = "<green>{time}</green>: <level>{level} {message}</level>"
logger.add(
    sys.stdout,
    format=log_format,
    serialize=True
)

Ändern Sie die Protokollstufe der Ausnahme

try:
    raise ValueError("error!")
except ValueError as e:
    logger.opt(exception=True).critical("Ändern Sie die Protokollstufe der Ausnahme")

Farbteil des Protokolls

logger.remove()
logger.add(sys.stderr, format="{time} {level} {message}", level="INFO")
logger.opt(colors=True).info("Färben Sie das Protokoll<blue>colors</blue>")

Fügen Sie die im Datensatz gespeicherten Informationen zum Protokoll hinzu

Protokollnachrichten sind mit "Datensatz" verknüpft. record ist ein Wörterbuchtyp und welche Art von Schlüssel er hat https://loguru.readthedocs.io/en/stable/api/logger.html Siehe "Das Aufnahmediktat" in.

logger.opt(record=True).info("Fügen Sie die im Datensatz gespeicherten Informationen zum Protokoll hinzu(eg. {record[thread]})")

Protokollausgabe ignoriert Format

logger.opt(raw=True).info("Protokollausgabe ignoriert Format\n")

Informationen zu Eltern (Anrufern) im Protokoll anzeigen

Die in der Protokollnachricht verwendeten Datensatzinformationen sind die des übergeordneten (Anrufers). Im Fall des folgenden Beispiels wird das Protokoll in "child_func ()" ausgegeben, aber "{function" like parent_func ", wodurch die übergeordneten Informationen im Protokoll angezeigt werden." 2020-05-30T18: 54: 32.505956 + 0000 INFO } `Geben Sie parent_func ein.

logger.remove()
logger.add(sys.stderr, format="{time} {level} {message} {function}", level="INFO")
def child_func():
    logger.opt(depth=1).info("Zeigen Sie übergeordnete Informationen im Protokoll an")

def parent_func():
    child_func()
parent_func()

Verwenden Sie Variablen nur für Nachrichten

Wenn eine Variable in einer Protokollnachricht verwendet wird, wird ihr Wert normalerweise in "record ['extra']" gespeichert. Wenn "capture = False" gesetzt ist, wird es nicht gespeichert.

logger.remove()
logger.add(sys.stderr, format="{time} {level} {message} {function}", level="INFO", serialize=True)
logger.opt(capture=False).info("{dest}Verwenden Sie Variablen nur für Nachrichten", dest="extra")

Ausgabebeispiel

# capture=Wenn falsch
{
    ...
    "record": {
        ...
        "extra": {},
        ...
        "message": "Keyword arguments not added to extra dict",
        ...
    }
}

# capture=Wenn wahr
{
    ...
    "record": {
        ...
        "extra": {"dest": "extra"},
        ...
        "message": "Keyword arguments not added to extra dict",
        ...
    }
}

faul: Kontrollieren Sie die Ausführung schwerer Funktionen

Führen Sie die Funktion nur aus, wenn der loglebel geeignet ist.

def test_lazy():
    print('exec test_razy')
    return 'exec test_razy'

logger.remove()
logger.add(sys.stderr, format="{time} {level} {message}", level="INFO")

#Die anzuzeigende Protokollstufe ist auf INFO eingestellt.
#Zu dieser Zeit faul=False(Standard), Das folgende DEBUG-Level-Protokoll wird nicht angezeigt, sondern getestet_lazy()Die Funktion wird ausgeführt.
logger.opt(lazy=False).debug("DEBUG LEVEL LOG: {x}", x=test_lazy())

# lazy=Stellen Sie True ein und verwenden Sie Lambda wie folgt.
#In diesem Fall wird kein Protokoll ausgegeben und getestet_lazy()Wird auch nicht ausgeführt.
logger.opt(lazy=True).debug("DEBUG LEVEL LOG: {x}", x=lambda: test_lazy())

#Wenn Sie zur DEBUG-Ebene wechseln und diese wie unten ausführen
#Das Ausführungsergebnis von Lambda wird in x gespeichert
logger.remove()
logger.add(sys.stderr, format="{time} {level} {message}", level="DEBUG")
logger.opt(lazy=True).debug("DEBUG LEVEL LOG: {x}", x=lambda: test_lazy())

pylogrus

Dokumentation: https://github.com/vmig/pylogrus

Eine Bibliothek, die die Protokollierung erweitert, sodass sie wie Golangs logrus verwendet werden kann. Die grundlegende Verwendung ist die gleiche wie lgging.

Wie man Pylogrus benutzt

Grundausgabe und Ausgabe in Datei

Entspricht der Protokollierung, außer dass "logging.setLoggerClass (PyLogrus)" zuerst ausgeführt wird und der TextFormatter von Pylogrus verwendet wird.

import logging
from pylogrus import PyLogrus, TextFormatter

logging.setLoggerClass(PyLogrus)
logger = logging.getLogger(__name__)  # type: PyLogrus
logger.setLevel(logging.DEBUG)

formatter = TextFormatter(datefmt='Z', colorize=True)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
logger.addHandler(ch)

ch = logging.FileHandler('/var/log/py_logrus_sample2.log')
ch.setLevel(logging.ERROR)
ch.setFormatter(formatter)
logger.addHandler(ch)

logger.debug("DEBUG MESSAGE")
logger.info("INFO MESSAGE")
logger.warning("WARNING MESSAGE")
logger.error("ERROR MESSAGE")

Fügen Sie der Nachricht ein Präfix hinzu

# [2020-05-31T13:12:14.428Z]    DEBUG [API] DEBUG MESSAGE
#Wird ausgegeben als
logger = logger.withPrefix("[API]")
logger.debug("DEBUG MESSAGE")

Fügen Sie der Nachricht ein Feld hinzu

# [2020-05-31T13:12:14.428Z]     INFO INFO MESSAGE; error_code=404
#Wird ausgegeben als
logger.withFields({'error_code': 404}).info("INFO MESSAGE")

Ausgabe im JSON-Format

Verwenden Sie JsonFormatter mit den zu aktivierenden Feldern.

enabled_fields = [
    ('name', 'logger_name'),
    ('asctime', 'service_timestamp'),
    ('levelname', 'level'),
    ('threadName', 'thread_name'),
    'message',
    ('exception', 'exception_class'),
    ('stacktrace', 'stack_trace'),
    'module',
    ('funcName', 'function')
]
formatter = JsonFormatter(datefmt='Z', enabled_fields=enabled_fields, indent=2, sort_keys=True)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
logger.addHandler(ch)

logger.debug("DEBUG MESSAGE")

Zusammenfassung

Wir haben drei Typen eingeführt: Logzero, Loguru und Pyrogrus. Es gibt Standardprotokollierung in Python, aber ich denke, Sie sollten diese verwenden, wenn Sie einfach ein schönes Protokoll ausgeben möchten. Persönlich fand ich Loguru einfach zu handhaben, aber wenn Sie an die Protokollierung gewöhnt sind, empfehle ich die Verwendung von Logzero und Pyrogrus.

[Python] 3 Arten von Bibliotheken, die die Protokollausgabe ein wenig verbessern [logzero, loguru, pyrogrus]