10 conseils pour maîtriser le module de journalisation Python

1. Personnaliser le logniveau

En plus des niveaux par défaut DEBUG, INFO, AVERTISSEMENT, ERREUR et CRITICAL, vous pouvez créer des niveaux personnalisés. Ceci est utile pour différencier des événements de gravité variable.

import logging

# 创建自定义日志级别
CUSTOM_LEVEL = logging.INFO + 5
logging.addLevelName(CUSTOM_LEVEL, "CUSTOM")

# 创建一个 Logger 并设置自定义日志级别
logger = logging.getLogger("my_logger")
logger.setLevel(CUSTOM_LEVEL)

2. Utilisez différents processeurs

Un gestionnaire est chargé d'envoyer les événements du journal vers une destination spécifique, telle qu'un fichier ou une console. Vous pouvez personnaliser le processeur pour répondre à vos besoins spécifiques.

import logging

# 创建一个 FileHandler 并设置日志文件名
file_handler = logging.FileHandler("my_log.txt")

# 创建一个 StreamHandler 并输出到控制台
stream_handler = logging.StreamHandler()

# 将处理器添加到 Logger
logger = logging.getLogger("my_logger")
logger.addHandler(file_handler)
logger.addHandler(stream_handler)

3. Utilisez des filtres

Les filtres vous permettent de filtrer les événements du journal en fonction de critères spécifiques. Ceci est utile pour enregistrer uniquement les événements intéressants.

import logging

# 创建一个过滤器以过滤 INFO 级别以上的事件
info_filter = logging.Filter()
info_filter.filter = lambda record: record.levelno >= logging.INFO

# 将过滤器添加到 Logger
logger = logging.getLogger("my_logger")
logger.addFilter(info_filter)

4. Formater la sortie du journal

Vous pouvez personnaliser le format des événements du journal pour fournir les informations dont vous avez besoin.

import logging

# 创建一个 FORMatter 并设置格式字符串
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")

# 将 Formatter 添加到处理器
handler = logging.StreamHandler()
handler.setFormatter(formatter)

# 将处理器添加到 Logger
logger = logging.getLogger("my_logger")
logger.addHandler(handler)

5. Utilisez le processeur de contexte

Le processeur de contexte vous permet d'ajouter des informations supplémentaires lors de la connexion. Ceci est utile pour suivre le contexte d'une demande ou d'une transaction.

import logging
from contextlib import contextmanager

# 创建一个上下文处理器以添加请求 ID
@contextmanager
def request_id_context(request_id):
previous_request_id = logging.currentframe().f_locals.get("request_id")
try:
logging.currentframe().f_locals["request_id"] = request_id
yield
finally:
logging.currentframe().f_locals["request_id"] = previous_request_id

# 使用上下文处理器
logger = logging.getLogger("my_logger")
with request_id_context("1234"):
logger.info("Received request")

6. Utiliser la configuration du dictionnaire

Vous pouvez facilement configurer le module Logging à l'aide d'un dictionnaire.

import logging

# 配置字典
logging_config = {
"version": 1,
"formatters": {
"default": {
"format": "%(asctime)s - %(levelname)s - %(message)s"
}
},
"handlers": {
"file": {
"class": "logging.FileHandler",
"filename": "my_log.txt",
"formatter": "default",
},
"console": {
"class": "logging.StreamHandler",
"formatter": "default",
}
},
"loggers": {
"my_logger": {
"handlers": ["file", "console"],
"level": "INFO",
}
}
}

# 从字典配置 Logging
logging.config.dictConfig(logging_config)

7. Intégrer des packages tiers

Le module de journalisation peut être intégré à des packages tiers tels que Sentry ou Rollbar. Cela vous permet d'envoyer facilement des événements de journal à un service distant.

import logging
import sentry_sdk

# 初始化 Sentry 并与 Logging 集成
sentry_sdk.init()
logging.basicConfig(level=logging.INFO, handlers=[sentry_sdk.handler.SentryHandler()])

8. Utilisez le support multi-threading

Le module de journalisation prend en charge les applications multi

thread . Il utilise le stockage local des threads pour garantir que chaque thread dispose de son propre processeur de journaux indépendant.

import logging
import threading

# 创建线程安全的 Logger
logger = logging.getLogger("my_logger")

# 创建一个线程并向 Logger 记录
def thread_function():
logger.info("Executing in a separate thread")

# 启动线程
thread = threading.Thread(target=thread_function)
thread.start()

9. Enregistrer les exceptions

Le module de journalisation peut enregistrer automatiquement les exceptions qui se produisent.

import logging

# 创建一个 Logger
logger = logging.getLogger("my_logger")

# 记录一个异常
try:
raise Exception("An error occurred")
except Exception as e:
logger.exception(e)

10. Utiliser la journalisation étendue

python 3.8 introduit la prise en charge de la journalisation étendue. Cela vous permet de créer des fonctions et des gestionnaires de journalisation personnalisés.

import logging

# 创建一个自定义日志记录函数
def my_log_function(logger, level, msg, *args, **kwargs):
# 您的自定义日志记录逻辑

# 添加自定义日志记录函数到 Logger
logger = logging.getLogger("my_logger")
logger.addHandler(logging.NullHandler())
logger.addFilter(logging.Filter())
logger.log = my_log_function

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!