logging — Enregistrer au lieu de print

logging est le module standard pour enregistrer le comportement de ton app par étapes. Écrire des sorties de débogage avec print rencontre des problèmes : tu oublies de les retirer en production, tu ne peux pas dire ce qui est important, et passer à une sortie fichier plus tard signifie tout réécrire. Avec logging, tu obtiens des niveaux d'importance (DEBUG / INFO / WARNING / ERROR / CRITICAL) pour filtrer la sortie, Formatter pour un formatage unifié, et Handler pour basculer les destinations (stdout / fichier / distant).

Niveaux de log — 5 paliers d'importance

logging a 5 niveaux, et seuls les messages au niveau fixé sur le Logger ou au-dessus sont émis. La pratique standard est DEBUG pendant le développement et INFO ou WARNING en production — et pouvoir changer le volume de sortie depuis un seul réglage sans toucher au code est la plus grande différence avec print.

D'abord, configure le formatage et le niveau avec basicConfig et émets un log INFO.

① Importe logging et configure basicConfig avec level=logging.INFO, format="[%(levelname)s] %(message)s", force=True

② Récupère le logger via logger = logging.getLogger("app")

③ Émets un log via logger.info("App démarrée")

(Si ton code s'exécute correctement, l'explication apparaîtra.)

Choisir entre WARNING / ERROR / DEBUG

Avec le logger configuré, appelle des niveaux autres que INFO et observe la sortie. Comme le niveau est fixé à INFO, DEBUG ne produit aucune sortie du tout — confirme aussi ça. C'est la fondation du comportement "changer le volume de sortie depuis un réglage" de logging.

Réutilise la config du logger de la Pratique 1 et émets à trois niveaux. Note : à INFO, DEBUG n'apparaît pas.

① Émets WARNING via logger.warning("Fichier de config obsolète")

② Émets ERROR via logger.error("Échec de connexion à la BD")

③ Appelle logger.debug("Trace détaillée") — au niveau INFO, rien ne devrait s'afficher

Émettre des logs vers un fichier

Les projets réels ont presque toujours besoin que les logs persistent dans un fichier, pas seulement à l'écran. Plus tard tu voudras grep pour une investigation post-mortem ou les ingérer dans un outil de monitoring. Passe filename="app.log" à basicConfig et la destination du root logger bascule vers un fichier — faire la même chose avec print signifierait réécrire chaque appel print, mais avec logging tu changes une ligne de config pour rediriger.

filemode est soit "a" (par défaut, append) soit "w" (overwrite). Append est le choix de production — garde l'historique. Overwrite est souvent plus pratique pendant le développement — repart à zéro à chaque fois. Pour émettre à la fois à l'écran et au fichier, tu sautes basicConfig et combines explicitement StreamHandler + FileHandler (couvert plus loin).

import logging
import os

# Crée d'abord le dossier parent (FileHandler ne le crée pas automatiquement)
os.makedirs("logs", exist_ok=True)

# Passe filename à basicConfig pour basculer la destination vers un fichier
logging.basicConfig(
    level=logging.INFO,
    format="[%(levelname)s] %(message)s",
    filename="logs/app.log",   # Sortie fichier
    filemode="w",               # "a" (append) ou "w" (overwrite)
    force=True,
)
logger = logging.getLogger("app")

logger.info("Démarré")
logger.warning("Config obsolète")
logger.error("Échec de connexion à la BD")

# Relit le fichier pour confirmer le contenu
with open("logs/app.log") as f:
    print(f.read(), end="")

Passe filename à basicConfig pour basculer les logs vers un fichier, puis relis le contenu depuis le disque.

① Utilise os.makedirs("logs", exist_ok=True) pour créer d'abord le dossier parent (FileHandler ne le crée pas automatiquement)

② Importe logging et appelle basicConfig avec level=logging.INFO, format="[%(levelname)s] %(message)s", filename="logs/app.log", filemode="w", force=True

③ Récupère le logger avec logger = logging.getLogger("app")

④ Émets 3 logs en INFO / WARNING / ERROR avec les messages "Démarré", "Config obsolète", "Échec de connexion à la BD"

⑤ Ouvre logs/app.log en lecture, puis sous le titre --- contenu de logs/app.log --- affiche le contenu sans saut de ligne final (print(content, end=""))

Définir les handlers dans un fichier séparé

À mesure que ton app grandit, extrais la config du logger (format, niveau, destination) dans un module dédié et fais que chaque module l'import. Les configs de logger ne se dupliquent plus, et tu changes le format/destination à un seul endroit. Le motif : construire un StreamHandler directement, attacher un Formatter, enregistrer avec logger.addHandler(...) — tout ça vit dans un fichier séparé.

# log_setup.py — module dédié à la config du logger
import logging

def setup_logger(name):
    logger = logging.getLogger(name)
    logger.setLevel(logging.INFO)

    if not logger.handlers:                       # Empêche l'enregistrement en double
        handler = logging.StreamHandler()
        handler.setFormatter(
            logging.Formatter("[%(name)s] [%(levelname)s] %(message)s")
        )
        logger.addHandler(handler)
        logger.propagate = False                  # Ne propage pas au root
    return logger

# main.py — importe log_setup et l'utilise
from log_setup import setup_logger

logger = setup_logger("orders")
logger.info("Commande reçue")

log_setup.py est fourni (ouvre le panneau de fichiers 📂 à gauche de la console pour l'inspecter). Depuis main.py, importe setup_logger et émets 3 logs avec le logger nommé "orders".

① Importe la fonction via from log_setup import setup_logger

② Récupère un logger avec logger = setup_logger("orders")

③ Émets 3 logs en INFO / WARNING / ERROR : "Commande reçue", "Stock faible", "L'API de paiement a retourné une erreur"

Format plus détaillé — horodatage / module / ligne

La chaîne de format de Formatter accepte des codes de remplacement style %(...)s, te permettant d'empaqueter les infos opérationnellement pertinentes sur une seule ligne. Voici les six codes les plus utilisés avec exemples. Les noms de logger peuvent être hiérarchiques via la forme séparée par points comme parent.child.grandchild — appeler getLogger(__name__) depuis chaque module enregistre automatiquement "quel module a émis ce log".

import logging

# Format détaillé pour la production
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(name)s] [%(levelname)s] %(funcName)s:%(lineno)d - %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    force=True,
)

logger = logging.getLogger("app.orders")

def process_order(order_id):
    logger.info(f"Traitement de la commande {order_id}")

process_order(1234)
# Exemple de sortie :
# 2024-12-01 10:30:45 [app.orders] [INFO] process_order:13 - Traitement de la commande 1234

Utilise 3 noms de logger hiérarchiques — app / app.orders / app.orders.payment — et montre de quel module vient chaque log avec %(name)s. En production tu ajouterais %(asctime)s pour l'horodatage, mais ici on s'en tient à la hiérarchie seule pour que la sortie reste déterministe.

① Importe logging et configure basicConfig avec level=logging.INFO, format="[%(name)s] [%(levelname)s] %(message)s", force=True

② Récupère 3 loggers : logging.getLogger("app"), logging.getLogger("app.orders"), logging.getLogger("app.orders.payment")

③ Émets un log depuis chacun : app appelle info("App démarrée"), app.orders appelle info("Commande reçue"), app.orders.payment appelle error("Erreur API de paiement")

Extraire la config dans un fichier yaml

Une fois que la configuration du logger devient complexe, au lieu de coder en dur format / handler / niveau dans Python, extrais-les dans un fichier de config yaml. logging.config.dictConfig(...) accepte une config en dict, donc parse simplement le yaml et passe-le pour configurer toute l'installation du logger. Ta base de code gère soudainement "des fichiers yaml différents pour production / staging / développement" sans changements.

# logging.yml — single source for logger config
version: 1
disable_existing_loggers: false
formatters:
  default:
    format: "[%(name)s] [%(levelname)s] %(message)s"
handlers:
  console:
    class: logging.StreamHandler
    formatter: default
    level: INFO
loggers:
  app:
    level: INFO
    handlers: [console]
    propagate: false

logging.yml est fourni (ouvre le panneau de fichiers 📂 pour l'inspecter). Parse en dict via yaml.safe_load, puis passe à logging.config.dictConfig pour configurer le logger.

① Importe logging, logging.config, et yaml

② Ouvre avec with open("logging.yml") as f : et convertis en dict via yaml.safe_load(f)

③ Passe le dict à logging.config.dictConfig(...) pour appliquer

④ Récupère le logger via logger = logging.getLogger("app") et émets 1 INFO et 1 WARNING : "Démarré avec config yaml" et "WARNING via yaml"

Rotation des logs

Si les logs continuent de croître, le fichier gonfle indéfiniment, donc la production a besoin de rotation — renommer les vieux fichiers en un nom séparé et les supprimer éventuellement. logging.handlers propose deux variantes — basée sur la taille et basée sur le temps — et tu choisis selon le cas d'usage.

RotatingFileHandler — basée sur la taille

RotatingFileHandler(filename, maxBytes, backupCount) est un Handler qui bascule vers un nouveau fichier quand maxBytes serait dépassé. Les vieux fichiers sont renommés avec un suffixe numérique (app.log.1 / app.log.2), et une fois backupCount dépassé le plus ancien est supprimé. Avec maxBytes=10_000_000 (10 Mo) + backupCount=5, tes logs cyclent dans un plafond de 60 Mo.

import logging
from logging.handlers import RotatingFileHandler

# Basée sur la taille : rotation quand maxBytes est dépassé
size_handler = RotatingFileHandler(
    "app.log",
    maxBytes=10_000_000,   # Rotation quand ce serait dépassé (10 Mo)
    backupCount=5,         # Conserve app.log.1 à app.log.5 (max 60 Mo total)
)
size_handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))

rotate_logging.yml est fourni (ouvre le panneau de fichiers 📂 pour l'inspecter). La config RotatingFileHandler (maxBytes=60 / backupCount=2) vit dans yaml, et le code la charge et l'utilise simplement.

① Importe os / shutil, supprime et recrée le dossier rotate/. Vide aussi tous les handlers du logger rotate_demo avec close + removeHandler (évite les interférences à la ré-exécution)

② Ouvre le yaml avec with open("rotate_logging.yml"), convertis via yaml.safe_load(f), et passe à logging.config.dictConfig(...) pour configurer le handler

③ Récupère logger = logging.getLogger("rotate_demo") et émets 15 logs en boucle : for i in range(15): logger.info(f"event {i:02d}")

④ Depuis os.listdir("rotate"), prends seulement les fichiers commençant par app.log, trie-les, et sous le titre Fichiers après rotation : ◯ affiche chaque nom de fichier sous la forme - nom_fichier sur sa propre ligne

TimedRotatingFileHandler — basée sur le temps

TimedRotatingFileHandler(filename, when, interval, backupCount) rotate à la frontière temporelle spécifiée par when. Utilise when="midnight" (chaque jour à 0h00), "H" (par heure), "M" (minute), "S" (seconde), "D" (jour), et ainsi de suite. Les backups portent des suffixes d'horodatage comme app.log.2024-12-01_00-00-00, donc le nom de fichier te dit "quand ce log a été écrit" directement.

import logging
from logging.handlers import TimedRotatingFileHandler

# Basée sur le temps : rotation chaque jour à minuit
day_handler = TimedRotatingFileHandler(
    "app.log",
    when="midnight",   # "S" sec / "M" min / "H" heure / "D" jour / "midnight" etc.
    interval=1,         # Tous les N unités (when="H", interval=6 signifie toutes les 6 heures)
    backupCount=30,     # Conserve 30 jours d'historique
)
day_handler.setFormatter(
    logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
)

time_logging.yml est fourni. La config TimedRotatingFileHandler (when : S (par seconde) / interval : 1 / backupCount : 3) vit dans yaml, et le code Python utilise time.sleep pour simuler le passage du temps afin de déclencher les rotations.

① Importe logging / os / shutil / time. Vide tous les handlers du logger trotate_demo avec close + removeHandler, puis supprime et recrée le dossier trotate/

② Ouvre time_logging.yml, convertis en dict via yaml.safe_load(f), et passe à logging.config.dictConfig(...) pour configurer

③ Récupère le logger et émets 3 logs avec sleep entre eux : logger.info(...) → time.sleep(1.2) → logger.info(...) → time.sleep(1.2) → logger.info(...), déclenchant 2 rotations

④ Depuis os.listdir("trotate"), sépare app.log (log courant) de tout le reste (backups horodatés), puis affiche Log courant présent : True/False et Nombre de backups : ◯