Python Academy · Leçon

Gestionnaires, formateurs et filtres

Acheminez les sorties de journalisation vers des fichiers, des flux et des destinations personnalisées.

Gestionnaires, formateurs et filtres est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Les gestionnaires acheminent les enregistrements de journal

Un gestionnaire envoie les enregistrements de journal vers une destination : console, fichier, point d’accès HTTP, etc. Un journaliseur peut avoir plusieurs gestionnaires.

import logging

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

sh = logging.StreamHandler()
logger.addHandler(sh)

logger.info("Goes to console")

StreamHandler

StreamHandler écrit dans un flux, par défaut sys.stderr. Transmettez sys.stdout pour obtenir une sortie sur stdout.

import logging, sys

logger = logging.getLogger("out")
handler = logging.StreamHandler(sys.stdout)
logger.addHandler(handler)
logger.warning("printed to stdout")

FileHandler

FileHandler ajoute les enregistrements à un fichier. Utilisez mode="w" pour l’écraser à chaque exécution.

import logging

logging.basicConfig(
    filename="app.log",
    filemode="a",
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s"
)
logging.info("Persisted to disk")

RotatingFileHandler

Faites pivoter automatiquement les fichiers de journal lorsqu’ils dépassent une limite de taille, tout en conservant N fichiers de sauvegarde.

from logging.handlers import RotatingFileHandler
import logging

handler = RotatingFileHandler(
    "app.log", maxBytes=1_000_000, backupCount=5
)
logging.getLogger().addHandler(handler)

TimedRotatingFileHandler

Faites pivoter les fichiers de journal selon un calendrier — chaque jour, chaque semaine ou chaque heure — une solution idéale pour les services exécutés longtemps.

from logging.handlers import TimedRotatingFileHandler
import logging

handler = TimedRotatingFileHandler(
    "app.log", when="midnight", backupCount=7
)
logging.getLogger().addHandler(handler)

Formatters

Un Formatter contrôle la disposition du texte de chaque enregistrement de journal. Attachez-le à un gestionnaire avec handler.setFormatter().

import logging

fmt = logging.Formatter(
    fmt="%(asctime)s %(levelname)-8s %(name)s — %(message)s",
    datefmt="%Y-%m-%dT%H:%M:%S"
)
handler = logging.StreamHandler()
handler.setFormatter(fmt)
logging.getLogger().addHandler(handler)

Filtrage au niveau des gestionnaires

Chaque gestionnaire possède son propre niveau. Un enregistrement doit respecter à la fois le niveau du journaliseur et celui du gestionnaire pour être émis.

import logging

logger = logging.getLogger("app")
logger.setLevel(logging.DEBUG)   # logger passes DEBUG+

err_handler = logging.FileHandler("errors.log")
err_handler.setLevel(logging.ERROR)  # only ERROR+
logger.addHandler(err_handler)

Filtres personnalisés

Créez une sous-classe de logging.Filter et redéfinissez filter(record) pour accepter ou rejeter les enregistrements selon n’importe quel critère.

import logging

class SensitiveFilter(logging.Filter):
    def filter(self, record):
        return "password" not in record.getMessage().lower()

handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())
logging.getLogger().addHandler(handler)

Ajouter des champs supplémentaires avec un filtre

Les filtres peuvent également modifier l’enregistrement pour y injecter des champs supplémentaires, par exemple un ID de requête, avant le formatage.

import logging

class RequestIDFilter(logging.Filter):
    def __init__(self, request_id):
        self.request_id = request_id
    def filter(self, record):
        record.request_id = self.request_id
        return True

# fmt: "%(request_id)s %(message)s"

Plusieurs gestionnaires pour un journaliseur

Ajoutez plusieurs gestionnaires pour envoyer simultanément les mêmes enregistrements de journal vers plusieurs destinations.

import logging

logger = logging.getLogger("multi")
logger.addHandler(logging.StreamHandler())             # console
logger.addHandler(logging.FileHandler("audit.log"))   # file
logger.setLevel(logging.INFO)
logger.info("Both destinations receive this")

Désactiver la propagation

Définissez logger.propagate = False pour empêcher les enregistrements de remonter jusqu’au journaliseur racine et d’être journalisés deux fois.

import logging

logger = logging.getLogger("mylib")
logger.propagate = False   # stays here, does not reach root
logger.addHandler(logging.StreamHandler())

Vérification rapide

Quelle méthode attache un Formatter à un Handler ?

Récapitulatif

Les gestionnaires acheminent les enregistrements, les formatters les mettent en forme et les filtres les laissent passer ou les bloquent sélectivement. Utilisez RotatingFileHandler pour les journaux limités par leur taille et TimedRotatingFileHandler pour une rotation fondée sur la date.

Questions Fréquemment Posées

La leçon « Gestionnaires, formateurs et filtres » est-elle gratuite ?

Oui — le texte complet de « Gestionnaires, formateurs et filtres » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestionnaires, formateurs et filtres » ?

Acheminez les sorties de journalisation vers des fichiers, des flux et des destinations personnalisées. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Gestionnaires, formateurs et filtres » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Python Academy