Le module logging de Python est un outil standard puissant conçu pour suivre les événements lors de l'exécution d'une application. Contrairement à la simple fonction print(), il permet de catégoriser les messages par importance, de les diriger vers plusieurs destinations simultanément et de formater précisément les données de sortie.

Architecture fondamentale du module

Le système repose sur quatre composants interdépendants :

• Logger : Le point d'entrée principal. Il expose l'interface utilisée par le code applicatif pour générer des journaux.
• Handler : Responsable de l'envoi des messages vers une destination spécifique (console, fichier, serveur distant via HTTP ou SMTP).
• Filter : Offre un contrôle granulaire pour déterminer quels enregistrements de log doivent être traités ou ignorés.
• Formatter : Définit la structure finale et l'apparence des messages (horodatage, nom du module, niveau de sévérité).

Hiérarchie des niveaux de log

Python définit plusieurs niveaux de sévérité par défaut, classés par ordre croissant :

1. DEBUG : Détails techniques pour le diagnostic.
2. INFO : Confirmation que tout fonctionne comme prévu.
3. WARNING : Indication d'un événement inattendu ou d'un problème potentiel.
4. ERROR : Problème sérieux ayant empêché une fonction de s'exécuter.
5. CRITICAL : Erreur grave risquant de provoquer l'arrêt du programme.

Mise en œuvre pratique

L'exemple suivant illustre comment configurer un logger qui enregistre les erreurs critiques dans la console tout en stockant tous les détails dans un fichier local.

import logging

def configurer_journalisation():
    # Création d'une instance personnalisée
    journal = logging.getLogger("SystemeAudit")
    journal.setLevel(logging.DEBUG)

    # Sortie vers un fichier (tous les messages)
    file_out = logging.FileHandler("audit_complet.log")
    file_out.setLevel(logging.DEBUG)

    # Sortie vers la console (erreurs uniquement)
    console_out = logging.StreamHandler()
    console_out.setLevel(logging.ERROR)

    # Définition du style
    masque = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_out.setFormatter(masque)
    console_out.setFormatter(masque)

    # Liaison des gestionnaires au logger
    journal.addHandler(file_out)
    journal.addHandler(console_out)
    
    return journal

# Test de fonctionnement
sys_log = configurer_journalisation()
sys_log.debug("Démarrage du processus de vérification.")
sys_log.error("Échec de la connexion à la base de données.")

Encapsulation dans une structure de classe

Pour faciliter la réutilisation dans de grands projets, il est souvent préférable d'encapsuler la logique de journalisation dans une classe dédiée.

import logging

class GestionnaireLogs:
    def __init__(self, nom_module, fichier_log="app_trace.log"):
        self.logger = logging.getLogger(nom_module)
        self.logger.setLevel(logging.DEBUG)
        
        # Format commun
        disposition = logging.Formatter('[%(levelname)s] %(asctime)s - %(message)s')

        # Configuration fichier
        f_handler = logging.FileHandler(fichier_log)
        f_handler.setFormatter(disposition)
        self.logger.addHandler(f_handler)

    def consigner_info(self, texte):
        self.logger.info(texte)

    def consigner_alerte(self, texte):
        self.logger.warning(texte)

    def consigner_critique(self, texte):
        self.logger.critical(texte)

# Utilisation
traceur = GestionnaireLogs("MoteurCalcul")
traceur.consigner_info("Initialisation des paramètres terminée.")
traceur.consigner_critique("Dépassement de mémoire détecté !")

Gestion multi-module et configuration par fichier

Dans une application complexe, le module logging garantit que l'appel à logging.getLogger('nom') renvoie toujours la même instance d'objet au sein d'un même interpréteur. Cela permet de centraliser la configuration via un fichier externe (souvent au format .conf ou .yaml).

Exemple de structure de fichier logging.conf :

[loggers]
keys=root,api

[handlers]
keys=console,file

[formatters]
keys=simple

[logger_root]
level=WARNING
handlers=console

[logger_api]
level=DEBUG
handlers=file
qualname=api

[handler_console]
class=StreamHandler
args=(sys.stdout,)
formatter=simple

[handler_file]
class=FileHandler
args=('api_gateway.log', 'a')
formatter=simple

[formatter_simple]
format=%(name)s - %(levelname)s - %(message)s

Intégration dans le code principal :

import logging.config

# Chargement de la configuration externe
logging.config.fileConfig('logging.conf')

# Récupération du logger spécifique défini dans le fichier
journal_api = logging.getLogger('api')

def traiter_requete():
    journal_api.debug("Réception d'un paquet réseau.")
    # Logique métier ici...
    journal_api.info("Requête traitée avec succès.")

traiter_requete()

Cette approche permet de modifier dynamiquement le comportement des logs (par exemple, augmenter la verbosité en production) sans toucher au code source de l'application.