Module logging de Python
En programmation, la journalisation est un outil très important. Elle nous aide à suivre l'état d'exécution des programmes, à déboguer les erreurs et à enregistrer des informations importantes.
Python fournit unloggingmodule spécialement conçu pour gérer les tâches de journalisation. Par rapport à de simplesprintinstructions,loggingle module est plus flexible et puissant, capable de répondre aux besoins de journalisation dans différents scénarios.
Pourquoi utiliser le module logging ?
- Flexibilité：
loggingLe module vous permet de définir les niveaux de journalisation, les formats et les destinations de sortie selon vos besoins. - Évolutivité: Vous pouvez facilement envoyer des journaux vers différentes cibles telles que des fichiers, la console, le réseau, etc.
- Journalisation structurée：
loggingLe module prend en charge la journalisation structurée, ce qui facilite l'analyse et le traitement ultérieurs. - Optimisation des performances: Par rapport à
print,loggingle module a été optimisé en termes de performances et convient à une utilisation dans des environnements de production.
Utilisation de base du module logging
1. Importer le module logging
Tout d'abord, nous devons importerloggingle module :
Exemple
import logging
2. Configurer le niveau de journalisation
Le niveau de journalisation est utilisé pour contrôler la verbosité des journaux.loggingLe module fournit les niveaux de journalisation suivants :
- DEBUG: Informations de débogage détaillées, généralement utilisées pendant le développement.
- INFO: Informations lors du fonctionnement normal du programme.
- WARNING: Indique des problèmes potentiels, mais le programme peut toujours fonctionner normalement.
- ERROR: Indique des erreurs dans le programme, empêchant certaines fonctionnalités de fonctionner correctement.
- CRITICAL: Indique des erreurs graves pouvant provoquer le plantage du programme.
Vous pouvez définir le niveau de journalisation avec le code suivant :
Exemple
logging.basicConfig(level=logging.DEBUG)
3. Enregistrer les journaux
Après avoir défini le niveau de journalisation, vous pouvez utiliser les méthodes suivantes pour enregistrer les journaux :
Exemple
logging.debug("Ceci est un message de débogage")
logging.info("Ceci est un message général")
logging.warning("Ceci est un message d'avertissement")
logging.error("Ceci est un message d'erreur")
logging.critical("Ceci est un message d'erreur critique")
logging.info("Ceci est un message général")
logging.warning("Ceci est un message d'avertissement")
logging.error("Ceci est un message d'erreur")
logging.critical("Ceci est un message d'erreur critique")
4. Format de sortie des journaux
Vous pouvez utiliserbasicConfigla méthode pour personnaliser le format de sortie des journaux. Par exemple :
Exemple
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
datefmt="%Y-%m-%d %H:%M:%S"
)
level=logging.DEBUG,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
datefmt="%Y-%m-%d %H:%M:%S"
)
5. Enregistrer les journaux dans un fichier
Par défaut, les logs sont envoyés vers la console. Si vous voulez enregistrer les logs dans un fichier, vous pouvez le configurer comme ceci :
Exemple
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
filename="app.log"
)
level=logging.DEBUG,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
filename="app.log"
)
Utilisation avancée du module logging
1. Utilisation de plusieurs loggers
Dans les grands projets, vous devrez peut-être créer des loggers indépendants pour différents modules ou composants. Cela peut être réalisé de la manière suivante :
Exemple
logger = logging.getLogger("my_logger")
logger.setLevel(logging.DEBUG)
# Créer un gestionnaire de fichier
file_handler = logging.FileHandler("my_logger.log")
file_handler.setLevel(logging.DEBUG)
# Créer un gestionnaire de console
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# Définir le format des logs
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# Ajouter des gestionnaires au logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)
# Enregistrer les logs
logger.debug("Ceci est un message de débogage")
logger.info("Ceci est un message général")
logger.setLevel(logging.DEBUG)
# Créer un gestionnaire de fichier
file_handler = logging.FileHandler("my_logger.log")
file_handler.setLevel(logging.DEBUG)
# Créer un gestionnaire de console
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# Définir le format des logs
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# Ajouter des gestionnaires au logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)
# Enregistrer les logs
logger.debug("Ceci est un message de débogage")
logger.info("Ceci est un message général")
2. Filtres de logs
Vous pouvez utiliser des filtres pour contrôler quels logs doivent être enregistrés. Par exemple :
Exemple
class MyFilter(logging.Filter):
def filter(self, record):
return record.levelno == logging.ERROR
logger.addFilter(MyFilter())
def filter(self, record):
return record.levelno == logging.ERROR
logger.addFilter(MyFilter())
3. Rotation des journaux
Lorsque le fichier journal devient trop volumineux, vous pouvez utiliserRotatingFileHandlerouTimedRotatingFileHandlerpour implémenter la rotation des journaux :
Exemple
from logging.handlers import RotatingFileHandler
handler = RotatingFileHandler("app.log", maxBytes=1024, backupCount=3)
logger.addHandler(handler)
handler = RotatingFileHandler("app.log", maxBytes=1024, backupCount=3)
logger.addHandler(handler)
Attributs et méthodes courants du module logging
1. Classes principales
| Classe | Description | Exemple |
|---|---|---|
logging.Logger | Logger, utilisé pour émettre des messages de journal (obtenu vialogging.getLogger(name)get) | logger = logging.getLogger("my_logger") |
logging.Handler | Handler, détermine la destination de sortie des journaux (comme les fichiers, la console, etc.) | handler = logging.FileHandler("app.log") |
logging.Formatter | Formatter, contrôle le format de sortie des journaux | formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') |
logging.Filter | Filter, utilisé pour un contrôle plus fin de l'enregistrement des journaux | filter = logging.Filter("module.name") |
2. Méthodes courantes de l'objet Logger
| Méthode | Description | Exemple |
|---|---|---|
logger.setLevel(level) | Définir le niveau de journalisation (tel quelogging.DEBUG、logging.INFO） | logger.setLevel(logging.DEBUG) |
logger.debug(msg) | Enregistrer les journaux de niveau DEBUG | logger.debug("调试信息") |
logger.info(msg) | Enregistrer les journaux de niveau INFO | logger.info("程序启动") |
logger.warning(msg) | Enregistrer les journaux de niveau WARNING | logger.warning("磁盘空间不足") |
logger.error(msg) | Enregistrer les journaux de niveau ERROR | logger.error("操作失败") |
logger.critical(msg) | Enregistrer les journaux de niveau CRITICAL | logger.critical("系统崩溃") |
logger.addHandler(handler) | Ajouter un handler | logger.addHandler(handler) |
logger.addFilter(filter) | Ajouter un filtre | logger.addFilter(filter) |
3. Types courants de Handler
| Type de Handler | Description | Exemple |
|---|---|---|
StreamHandler | Sortie vers un flux (tel que la console) | handler = logging.StreamHandler() |
FileHandler | Sortie vers un fichier | handler = logging.FileHandler("app.log") |
RotatingFileHandler | Fractionner les journaux par taille de fichier | handler = logging.RotatingFileHandler("app.log", maxBytes=1e6, backupCount=3) |
TimedRotatingFileHandler | Fractionner les journaux par temps | handler = logging.TimedRotatingFileHandler("app.log", when="midnight") |
SMTPHandler | Envoyer les journaux par e-mail | handler = logging.SMTPHandler("mail.example.com", "[email protected]", "[email protected]", "Error Log") |
4. Niveaux de journalisation (constantes)
| Niveau | Valeur | Description |
|---|---|---|
CRITICAL | 50 | Erreur critique, le programme risque de ne pas pouvoir continuer à s'exécuter |
ERROR | 40 | Erreur, mais le programme peut toujours s'exécuter |
WARNING | 30 | Message d'avertissement (niveau par défaut) |
INFO | 20 | Informations d'exécution du programme |
DEBUG | 10 | Informations de débogage |
NOTSET | 0 | Hériter du niveau du logger parent |
5. Champs de format courants de Formatter
| Champ | Description | Exemple de sortie |
|---|---|---|
%(asctime)s | Heure de création du journal | 2023-01-01 12:00:00,123 |
%(levelname)s | Nom du niveau de journalisation | INFO |
%(message)s | Contenu du message de journalisation | Program started successfully. |
%(name)s | Nom du journaliseur | my_logger |
%(filename)s | Nom du fichier où le journal a été généré | app.py |
%(lineno)d | Numéro de ligne où le journal a été généré | 42 |
%(funcName)s | Nom de la fonction où le journal a été généré | main |
6. Méthodes de configuration rapide
| Méthode | Description | Exemple |
|---|---|---|
logging.basicConfig() | Configuration en un clic du niveau de journalisation, des gestionnaires et du format (généralement appelée au point d'entrée du programme) | logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s') |
Paramètres communs：
level: Définir le niveau du journaliseur racinefilename: Sortie vers un fichierfilemode: Mode de fichier (tel que'w'écraser)format: Chaîne de formatdatefmt: Format de date (tel que"%Y-%m-%d %H:%M:%S"）
Exemple
1. Configuration de base
Exemple
import logging
# Configurer la journalisation
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
filename='app.log'
)
# Utiliser
logger = logging.getLogger("my_app")
logger.info("Programme démarré")
# Configurer la journalisation
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
filename='app.log'
)
# Utiliser
logger = logging.getLogger("my_app")
logger.info("Programme démarré")
2. Configuration complexe avec plusieurs gestionnaires
Exemple
import logging
# Créer un journaliseur
logger = logging.getLogger("my_module")
logger.setLevel(logging.DEBUG)
# Gestionnaire de console
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.WARNING)
# Gestionnaire de fichier
file_handler = logging.FileHandler("debug.log")
file_handler.setLevel(logging.DEBUG)
# Formatage
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
# Ajouter des gestionnaires
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# Utiliser
logger.debug("Debug message") # Écrire uniquement dans le fichier
logger.warning("Warning!") # Afficher à la fois dans la console et dans le fichier
# Créer un journaliseur
logger = logging.getLogger("my_module")
logger.setLevel(logging.DEBUG)
# Gestionnaire de console
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.WARNING)
# Gestionnaire de fichier
file_handler = logging.FileHandler("debug.log")
file_handler.setLevel(logging.DEBUG)
# Formatage
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
# Ajouter des gestionnaires
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# Utiliser
logger.debug("Debug message") # Écrire uniquement dans le fichier
logger.warning("Warning!") # Afficher à la fois dans la console et dans le fichier
3. Fractionnement des journaux
Exemple
from logging.handlers import RotatingFileHandler
handler = RotatingFileHandler(
"app.log", maxBytes=1e6, backupCount=3 # 1MB par fichier, conserver 3 sauvegardes
)
logger.addHandler(handler)