Maison > développement back-end > Tutoriel Python > 10 conseils pour maîtriser le module de journalisation Python

10 conseils pour maîtriser le module de journalisation Python

PHPz
Libérer: 2024-02-21 09:30:04
avant
478 Les gens l'ont consulté

掌握 Python Logging 模块的 10 个技巧

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)
Copier après la connexion

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)
Copier après la connexion

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)
Copier après la connexion

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)
Copier après la connexion

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")
Copier après la connexion

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)
Copier après la connexion

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()])
Copier après la connexion

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()
Copier après la connexion

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)
Copier après la connexion

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
Copier après la connexion

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!

Étiquettes associées:
source:lsjlt.com
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal