En bref :
- Créer des fichiers logs en Python se fait principalement avec le module logging.
- Centraliser le logger évite les doublons et facilite la analyse des logs.
- Rotation des logs + format de log adapté = maintenance simple en production.
- Enrichir les logs (extra) permet de suivre le contexte métier sans fouiller le code.
- Ne pas logguer de données sensibles et prévoir une gestion des erreurs claire.
Chapô — pourquoi ce guide est utile maintenant :
Depuis que j’ai intégré la startup fictive *DataFlux* pour industrialiser nos pipelines, la capacité à produire des fichiers logs lisibles et fiables est devenue une exigence non négociable. J’ai vu des projets perdre des heures parce que la journalisation était dispersée, sans format de log commun ni mécanisme de rotation des logs. Ce tutoriel rassemble des recettes éprouvées pour configurer un logger central, écrire des logs structurés (texte ou JSON), gérer la gestion des erreurs et inclure du contexte métier utile pour la analyse des logs. Je partage des exemples concrets, des astuces pour éviter les pièges et un modèle de configuration réutilisable pour des projets Python modernes.
Réponse rapide : Pour créer des fichiers logs avec logging, configurez un logger central via get_logger(), ajoutez un FileHandler ou RotatingFileHandler, définissez le niveau de log et un format de log clair ; enrichissez avec extra pour le contexte métier et évitez de logguer des données sensibles.
Configurer un logger central pour écrire des fichiers logs
Dans mes projets, j’ai systématiquement un fichier config/logger.py qui instancie le logger. Cela évite les doublons de handlers et facilite la journalisation homogène.
Exemple minimal pratique que j’utilise :
import logging
from logging.handlers import RotatingFileHandler
logger = logging.getLogger(__name__)
if not logger.hasHandlers():
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(‘[%(asctime)s] %(levelname)s | %(name)s | %(message)s’)
file_handler = RotatingFileHandler(‘logs/application.log’, maxBytes=5*1024*1024, backupCount=3)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
Avec cette base, on obtient des fichiers logs versionnés automatiquement et un format de log lisible. Insight : centraliser évite les doublons de messages.
Pourquoi utiliser RotatingFileHandler pour la rotation des logs
Sur un pipeline data, un fichier unique peut exploser en taille et devenir inutilisable. J’ai vu des serveurs en prod remplir des disques faute de rotation des logs.
Le handler RotatingFileHandler permet de limiter la taille et conserver un historique (backupCount). C’est indispensable pour la résilience en production et la continuité de service. Insight : la rotation préserve l’espace disque et rend l’archivage prévisible.
Structurer les messages : format de log et contexte métier
Un bon format de log doit inclure au minimum : date/heure, niveau de log, nom du module et message. Pour les projets data, j’ajoute des champs métiers via extra (utilisateur, job_id, table).
Exemple :
logger.info(‘Import terminé’, extra={‘user’:’analyste1′,’job_id’:’batch_20260301′})
Il faut adapter le formatter pour afficher ces clés. Pour l’intégration avec ELK/Datadog, je privilégie parfois le JSON (package python-json-logger). Insight : structurer les logs facilite la recherche et la corrélation.
Journaliser des objets complexes sans alourdir les fichiers logs
Logguer un DataFrame complet est rarement pertinent ; je préfère enregistrer la forme, les types et un aperçu. Exemple :
logger.info(f’DataFrame : {df.shape[0]}x{df.shape[1]}’)
logger.debug(f’Colonnes : {list(df.columns)}’)
Cela permet une analyse des logs efficace sans saturer les fichiers logs. Insight : concision > volume pour les objets complexes.
Gestion des erreurs et tracebacks dans les fichiers logs
La gestion des erreurs passe par une remontée claire des exceptions et du traceback. J’utilise logger.exception() dans les blocs except pour capturer la pile d’appel.
Exemple :
try:
do_something()
except Exception as e:
logger.exception(‘Erreur lors du traitement’)
Le traceback complet facilite le diagnostic et réduit les allers-retours. Insight : logger.exception() = gain de temps inestimable en production.
Bonnes pratiques opérationnelles
Après des années sur des projets web et data, voici la checklist que j’applique systématiquement :
- Un seul fichier logger.py pour toute l’application.
- Éviter les doublons de handlers avec if not logger.hasHandlers().
- Ne pas logguer de données sensibles (PII, tokens).
- Adapter le niveau de log selon l’environnement (DEBUG local, INFO prod).
- Utiliser la rotation des logs et surveiller l’espace disque.
Insight : ces règles simples évitent 80 % des problèmes opérationnels liés aux logs.
Cas d’usage et intégrations courantes
Pour automatiser et surveiller, j’ai relié nos fichiers logs à des pipelines d’ingestion (ELK) et à des alertes. Les logs JSON sont précieux pour Datadog ou Splunk.
Si vous êtes intéressé par le traitement en parallèle (pour générer des logs depuis plusieurs workers), pensez à la synchronisation et aux handlers adaptés ; la gestion du multithreading/multiprocessing est abordée en profondeur dans des ressources spécialisées.
Pour approfondir les exceptions et la gestion fine des erreurs, je recommande cet article pratique sur la gestion des exceptions en Python.
Pour compléter la manipulation de fichiers souvent couplée à la journalisation, j’utilise régulièrement ces recettes sur la gestion des fichiers avec shutil et pathlib.
Insight : relier logs et monitoring transforme la capacité de diagnostic.
Checklist rapide avant mise en production
- Vérifier le niveau de log (INFO/ERROR en prod).
- Activer la rotation des logs et définir backupCount.
- Valider le format (texte lisible ou JSON selon l’écosystème).
- Tester la capture du traceback avec logger.exception().
- Automatiser l’archivage et la purge si nécessaire.
Insight : une checklist réduit les incidents liés aux logs.
Comment écrire rapidement dans un fichier log en Python ?
Utilisez le module logging : configurez logging.basicConfig(filename=’logfile.log’, level=logging.INFO, format='[%(asctime)s] %(levelname)s %(message)s’) puis appelez logger = logging.getLogger() et logger.info(‘message’).
Quelle différence entre FileHandler et RotatingFileHandler ?
Le FileHandler écrit dans un fichier unique. Le RotatingFileHandler gère la rotation des logs en limitant la taille et en conservant des backups, pratique en production.
Comment enregistrer un traceback complet dans les logs ?
Dans un bloc except, utilisez logger.exception(‘message’) : cela enregistre le message, l’exception et le traceback complet dans le fichier de log.
Peut-on structurer les logs pour un ELK/Datadog ?
Oui : formatez en JSON avec le paquet python-json-logger et utilisez un formatter JSON. Cela facilite l’indexation et la analyse des logs.