Le module de journalisation Python définit des fonctions et des classes qui implémentent une journalisation flexible des événements pour les applications et les bibliothèques.
Pendant le processus de développement du programme, de nombreux programmes ont besoin d'enregistrer des journaux, et les informations contenues dans les journaux incluent les journaux d'accès normaux au programme et peuvent également inclure des erreurs, des avertissements et d'autres informations. Le module de journalisation de Python fournit une interface de journal standard, qui peut être transmis. Il stocke les journaux dans différents formats et la journalisation fournit un ensemble de fonctions pratiques pour une utilisation simple de la journalisation.
Le principal avantage de l'utilisation du module Python Logging est que tous les modules Python peuvent participer à la journalisation. Le module Logging fournit un grand nombre de fonctions flexibles.
Il est simple et pratique de nous aider à générer les informations de journal requises :
Lorsque vous utilisez Python pour écrire des programmes ou des scripts, un problème courant est que le journal doit être supprimé. D'une part, cela peut nous aider à résoudre les problèmes lorsqu'il y a un problème avec le programme, et d'autre part, cela peut nous aider à enregistrer les informations qui nécessitent notre attention.
Cependant, si nous utilisons le module de journalisation intégré, nous devons effectuer différentes initialisations et autres travaux connexes. Pour les étudiants qui ne connaissent pas ce module, c'est quand même un peu difficile, comme la nécessité de configurer Handler/Formatter, etc. À mesure que la complexité de l'entreprise augmente, les exigences en matière de collecte de journaux augmentent, telles que : la classification des journaux, le stockage de fichiers, l'écriture asynchrone, les types personnalisés, etc.
loguru est une bibliothèque de journalisation tierce simple et puissante en Python. vise à rendre la journalisation Python moins pénible en ajoutant une gamme de fonctionnalités utiles qui répondent aux mises en garde du logger standard.
pip install loguru
Il existe de nombreux avantages, les suivants sont les plus importants :
Il peut être utilisé immédiatement. , aucune préparation n'est requise
Aucune initialisation requise, les fonctions importées peuvent être utilisées
Méthodes de journalisation et de vidage/rétention/compression de fichiers plus faciles
Sortie formatée en chaîne plus élégante
Peut être utilisé dans les threads ou principales exceptions Catch dans les threads
Vous pouvez définir différents niveaux de styles de journalisation
Prise en charge de la sécurité asynchrone, des threads et des multi-processus
Prise en charge du calcul paresseux
Convient aux scripts et aux bibliothèques
Complètement compatible avec la journalisation standard
Meilleur traitement de la date et de l'heure
from loguru import logger
logger.debug("That's it, beautiful and simple logging!")Pas besoin d'initialiser, importez simplement la fonction à utiliser, puis vous devez vous demander, comment résoudre le problème ?
Comment ajouter un gestionnaire ?
Comment définir le formatage du journal ?
Comment filtrer les messages ?
Comment définir le niveau de journalisation ?
# add
logger.add(sys.stderr, \
format="{time} {level} {message}",\
filter="my_module",\
level="INFO")N'est-ce pas très facile~
# 日志文件记录
logger.add("file_{time}.log")
# 日志文件转存
logger.add("file_{time}.log", rotation="500 MB")
logger.add("file_{time}.log", rotation="12:00")
logger.add("file_{time}.log", rotation="1 week")
# 多次时间之后清理
logger.add("file_X.log", retention="10 days")
# 使用zip文件格式保存
logger.add("file_Y.log", compression="zip")logger.info(
"If you're using Python {}, prefer {feature} of course!",
3.10, feature="f-strings")@logger.catch
def my_function(x, y, z):
# An error? It's caught anyway!
return 1 / (x + y + z)
my_function(0, 0, 0)Loguru ajoutera automatiquement différentes couleurs pour distinguer les différents niveaux de journalisation, et prend également en charge les couleurs personnalisées ~
logger.add(sys.stdout,
colorize=True,
format="<green>{time}</green> <level>{message}</level>")
logger.add('logs/z_{time}.log',
level='DEBUG',
format='{time:YYYY-MM-DD :mm:ss} - {level} - {file} - {line} - {message}',
rotation="10 MB")Par défaut, les informations de journal ajoutées à l'enregistreur sont thread-safe. Mais ce n'est pas sûr pour plusieurs processus, nous pouvons garantir l'intégrité des journaux en ajoutant le paramètre enqueue.
Si nous souhaitons utiliser la journalisation dans des tâches asynchrones, nous pouvons également utiliser les mêmes paramètres pour le garantir. Et attendez la fin de l’exécution via complete().
# 异步写入
logger.add("some_file.log", enqueue=True) Vous avez bien lu, juste enqueue=True peut être exécuté de manière asynchrone
est utilisée pour enregistrer les traces de bugs des exceptions qui se produisent dans le code, Loguru en permettant d'afficher l'intégralité de la trace de la pile ( y compris la valeur des variables) pour vous aider à identifier le problème
logger.add("out.log", backtrace=True, diagnose=True)
def func(a, b):
return a / b
def nested(c):
try:
func(5, c)
except ZeroDivisionError:
logger.exception("What?!")
nested(0)Sérialisez les journaux pour faciliter l'analyse ou la transmission de la structure des données, utilisez le paramètre de sérialisation avant d'envoyer chaque message de journal au récepteur configuré. avant de le convertir en chaîne JSON.
De plus, en utilisant la méthode bind(), les messages de l'enregistreur peuvent être mis en contexte en modifiant les propriétés d'enregistrement supplémentaires. Vous pouvez également avoir un contrôle plus précis sur la journalisation en combinant bind() et filter.
Enfin, la méthode patch() permet d'ajouter des valeurs dynamiques au dict d'enregistrement pour chaque nouveau message.
# 序列化为json格式
logger.add(custom_sink_function, serialize=True)
# bind方法的用处
logger.add("file.log", format="{extra[ip]} {extra[user]} {message}")
context_logger = logger.bind(ip="192.168.2.174", user="someone")
context_logger.info("Contextualize your logger easily")
context_logger.bind(user="someone_else").info("Inline binding of extra attribute")
context_logger.info("Use kwargs to add context during formatting: {user}", user="anybody")
# 粒度控制
logger.add("special.log", filter=lambda record: "special" in record["extra"])
logger.debug("This message is not logged to the file")
logger.bind(special=True).info("This message, though, is logged to the file!")
# patch()方法的用处
logger.add(sys.stderr, format="{extra[utc]} {message}")
loggerlogger = logger.patch(lambda record: record["extra"].update(utc=datetime.utcnow()))Parfois, vous souhaitez enregistrer des détails dans un environnement de production sans affecter les performances, vous pouvez utiliser la méthode opt() pour y parvenir.
logger.opt(lazy=True).debug("If sink level <= DEBUG: {x}", x=lambda: expensive_function(2**64))
# By the way, "opt()" serves many usages
logger.opt(exception=True).info("Error stacktrace added to the log message (tuple accepted too)")
logger.opt(colors=True).info("Per message <blue>colors</blue>")
logger.opt(record=True).info("Display values from the record (eg. {record[thread]})")
logger.opt(raw=True).info("Bypass sink formatting\n")
logger.opt(depth=1).info("Use parent stack context (useful within wrapped functions)")
logger.opt(capture=False).info("Keyword arguments not added to {dest} dict", dest="extra")new_level = logger.level("SNAKY", no=38, color="<yellow>", icon="????")
logger.log("SNAKY", "Here we go!")# For scripts
config = {
"handlers": [
{"sink": sys.stdout, "format": "{time} - {message}"},
{"sink": "file.log", "serialize": True},
],
"extra": {"user": "someone"}
}
logger.configure(**config)
# For libraries
logger.disable("my_library")
logger.info("No matter added sinks, this message is not displayed")
logger.enable("my_library")
logger.info("This message however is propagated to the sinks")Besoin de convertir les messages Loguru en journaux standard ?
Vous souhaitez intercepter les messages de journal standard et les résumer dans Loguru ?
handler = logging.handlers.SysLogHandler(address=('localhost', 514))
logger.add(handler)
class PropagateHandler(logging.Handler):
def emit(self, record):
logging.getLogger(record.name).handle(record)
logger.add(PropagateHandler(), format="{message}")
class InterceptHandler(logging.Handler):
def emit(self, record):
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except ValueError:
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frameframe = frame.f_back
depth += 1
logger.opt(depthdepth=depth, exception=record.exc_info).log(level, record.getMessage())
logging.basicConfig(handlers=[InterceptHandler()], level=0)从生成的日志中提取特定的信息通常很有用，这就是为什么 Loguru 提供了一个 parse() 方法来帮助处理日志和正则表达式。
pattern = r"(?P<time>.*) - (?P<level>[0-9]+) - (?P<message>.*)" # Regex with named groups
caster_dict = dict(time=dateutil.parser.parse, level=int) # Transform matching groups
for groups in logger.parse("file.log", pattern, cast=caster_dict):
print("Parsed:", groups)
# {"level": 30, "message": "Log example", "time": datetime(2018, 12, 09, 11, 23, 55)}import notifiers
params = {
"username": "you@gmail.com",
"password": "abc123",
"to": "dest@gmail.com"
}
# Send a single notification
notifier = notifiers.get_notifier("gmail")
notifier.notify(message="The application is running!", **params)
# Be alerted on each error message
from notifiers.logging import NotificationHandler
handler = NotificationHandler("gmail", defaults=params)
logger.add(handler, level="ERROR")现在最关键的一个问题是如何兼容别的 logger，比如说 tornado 或者 django 有一些默认的 logger。
经过研究，最好的解决方案是参考官方文档的，完全整合 logging 的工作方式。比如下面将所有的 logging都用 loguru 的 logger 再发送一遍消息。
import logging
import sys
from pathlib import Path
from flask import Flask
from loguru import logger
app = Flask(__name__)
class InterceptHandler(logging.Handler):
def emit(self, record):
loggerlogger_opt = logger.opt(depth=6, exception=record.exc_info)
logger_opt.log(record.levelname, record.getMessage())
def configure_logging(flask_app: Flask):
"""配置日志"""
path = Path(flask_app.config['LOG_PATH'])
if not path.exists():
path.mkdir(parents=True)
log_name = Path(path, 'sips.log')
logging.basicConfig(handlers=[InterceptHandler(level='INFO')], level='INFO')
# 配置日志到标准输出流
logger.configure(handlers=[{"sink": sys.stderr, "level": 'INFO'}])
# 配置日志到输出到文件
logger.add(log_name, rotation="500 MB", encoding='utf-8', colorize=False, level='INFO')介绍，主要函数的使用方法和细节 - add()的创建和删除
add() 非常重要的参数 sink 参数
具体的实现规范可以参见官方文档
可以实现自定义 Handler 的配置，比如 FileHandler、StreamHandler 等等
可以自行定义输出实现
代表文件路径，会自动创建对应路径的日志文件并将日志输出进去
例如 sys.stderr 或者 open(‘file.log’, ‘w’) 都可以
可以传入一个 file 对象
可以直接传入一个 str 字符串或者 pathlib.Path 对象
可以是一个方法
可以是一个 logging 模块的 Handler
可以是一个自定义的类
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
):另外添加 sink 之后我们也可以对其进行删除，相当于重新刷新并写入新的内容。删除的时候根据刚刚 add 方法返回的 id 进行删除即可。可以发现，在调用 remove 方法之后，确实将历史 log 删除了。但实际上这并不是删除，只不过是将 sink 对象移除之后，在这之前的内容不会再输出到日志中，这样我们就可以实现日志的刷新重新写入操作
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')
我们在开发流程中, 通过日志快速定位问题, 高效率解决问题, 我认为 loguru 能帮你解决不少麻烦, 赶快试试吧~
当然, 使用各种也有不少麻烦, 例如:
--- Logging error in Loguru Handler #3 ---
Record was: None
Traceback (most recent call last):
File "/usr/local/lib/python3.9/site-packages/loguru/_handler.py", line 272, in _queued_writer
message = queue.get()
File "/usr/local/lib/python3.9/multiprocessing/queues.py", line 366, in get
res = self._reader.recv_bytes()
File "/usr/local/lib/python3.9/multiprocessing/connection.py", line 221, in recv_bytes
buf = self._recv_bytes(maxlength)
File "/usr/local/lib/python3.9/multiprocessing/connection.py", line 419, in _recv_bytes
buf = self._recv(4)
File "/usr/local/lib/python3.9/multiprocessing/connection.py", line 384, in _recv
chunk = read(handle, remaining)
OSError: [Errno 9] Bad file descriptor
--- End of logging error ---
解决办法:
尝试将logs文件夹忽略git提交, 避免和服务器文件冲突即可;
当然也不止这个原因引起这个问题, 也可能是三方库(ciscoconfparse)冲突所致.解决办法: https://github.com/Delgan/loguru/issues/534
File "/home/ronaldinho/xxx/xxx/venv/lib/python3.9/site-packages/loguru/_logger.py", line 939, in add
handler = Handler(
File "/home/ronaldinho/xxx/xxx/venv/lib/python3.9/site-packages/loguru/_handler.py", line 86, in __init__
self._queue = multiprocessing.SimpleQueue()
File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/context.py", line 113, in SimpleQueue
return SimpleQueue(ctx=self.get_context())
File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/queues.py", line 342, in __init__
self._rlock = ctx.Lock()
File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/context.py", line 68, in Lock
return Lock(ctx=self.get_context())
File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/synchronize.py", line 162, in __init__
File "/home/ronaldinho/.pyenv/versions/3.9.4/lib/python3.9/multiprocessing/synchronize.py", line 57, in __init__
OSError: [Errno 24] Too many open files
你可以 remove()添加的处理程序，它应该释放文件句柄。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
