Python Academy · Leçon

Journalisation structurée

Émettez des journaux au format JSON pour obtenir une sortie lisible par les machines.

Journalisation structurée est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Qu’est-ce que la journalisation structurée ?

La journalisation structurée émet les enregistrements sous forme de données lisibles par machine (JSON) plutôt que de texte libre, ce qui facilite leur indexation, leur recherche et le déclenchement d’alertes.

import logging, json

def log_json(level, msg, **kw):
    record = {"level": level, "msg": msg, **kw}
    print(json.dumps(record))

log_json("INFO", "Request received", path="/api/users", method="GET")

Formatter JSON personnalisé

Créez une sous-classe de logging.Formatter pour émettre du JSON plutôt que du texte brut.

import logging, json

class JSONFormatter(logging.Formatter):
    def format(self, record):
        return json.dumps({
            "time": self.formatTime(record),
            "level": record.levelname,
            "name": record.name,
            "msg": record.getMessage(),
        })

handler = logging.StreamHandler()
handler.setFormatter(JSONFormatter())
logging.getLogger().addHandler(handler)

python-json-logger

Le paquet python-json-logger fournit un Formatter JSON prêt à l’emploi, avec des champs standard et supplémentaires.

# pip install python-json-logger
import logging
from pythonjsonlogger import jsonlogger

logger = logging.getLogger()
handler = logging.StreamHandler()
handler.setFormatter(jsonlogger.JsonFormatter())
logger.addHandler(handler)
logger.info("User created", extra={"user_id": 42})

structlog

structlog est une bibliothèque tierce très utilisée qui sépare l’accumulation du contexte du formatage et prend en charge les chaînes de traitement des processeurs.

# pip install structlog
import structlog

log = structlog.get_logger()
log = log.bind(request_id="abc123")
log.info("payment_processed", amount=49.99, currency="USD")

Associer un contexte avec structlog

structlog vous permet d’associer des paires clé-valeur à un journaliseur ; elles sont conservées lors de tous les appels suivants.

import structlog

log = structlog.get_logger().bind(
    service="auth",
    env="prod"
)
log.warning("login_failed", user="alice", reason="bad_password")
# {service:auth, env:prod, user:alice, reason:bad_password}

Ajouter des horodatages et les informations sur l’appelant

Les processeurs peuvent enrichir automatiquement les enregistrements. Ajoutez TimeStamper et CallsiteParameterAdder à chaque enregistrement de journal.

import structlog

structlog.configure(
    processors=[
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.CallsiteParameterAdder([structlog.processors.CallsiteParameter.FILENAME]),
        structlog.processors.JSONRenderer(),
    ]
)

Journaliser les ID de requête dans les applications web

Dans un framework web, associez un ID de requête au début de chaque requête afin que chaque ligne de journal générée pendant cette requête l’inclue.

import structlog

def middleware(request, call_next):
    req_id = request.headers.get("X-Request-Id", generate_id())
    log = structlog.get_logger().bind(request_id=req_id)
    log.info("request_started", path=request.url.path)
    response = call_next(request)
    log.info("request_finished", status=response.status_code)
    return response

Format de journal ECS

Elastic Common Schema (ECS) est un format de journal JSON standard utilisé par Elastic Stack. Utilisez ecs-logging pour Python.

# pip install ecs-logging
import logging
import ecs_logging

logger = logging.getLogger("app")
handler = logging.StreamHandler()
handler.setFormatter(ecs_logging.StdlibFormatter())
logger.addHandler(handler)
logger.info("Event logged in ECS format")

Systèmes d’agrégation des journaux

Les journaux JSON structurés s’intègrent naturellement aux outils d’agrégation : Elasticsearch/Kibana (ELK), Grafana Loki, Datadog, AWS CloudWatch Logs Insights.

# Loki query example:
# {app="myservice"} | json | level="ERROR"

# CloudWatch Insights:
# fields @timestamp, level, msg
# | filter level = "ERROR"
# | sort @timestamp desc

Éviter les PII dans les journaux

Supprimez les informations permettant d’identifier une personne avant la journalisation. Utilisez un processeur ou un filtre personnalisé pour masquer les adresses e-mail, les jetons et les mots de passe.

import re

def mask_pii(_, __, event_dict):
    msg = event_dict.get("event", "")
    event_dict["event"] = re.sub(
        r"[\w.+-]+@[\w-]+\.[\w.]+", "***@***.***", msg
    )
    return event_dict

Compromis entre journaux structurés et non structurés

Les journaux structurés sont faciles à rechercher et permettent de déclencher des alertes, mais ils sont verbeux. Combinez la journalisation structurée en production avec un format lisible par l’humain en développement, au moyen d’une configuration fondée sur l’environnement.

import structlog, os

if os.getenv("ENV") == "production":
    renderer = structlog.processors.JSONRenderer()
else:
    renderer = structlog.dev.ConsoleRenderer()

structlog.configure(processors=[renderer])

Vérification rapide

Quel est le principal avantage des journaux structurés en JSON par rapport aux journaux en texte brut ?

Récapitulatif

La journalisation structurée émet des enregistrements JSON clé-valeur. Utilisez un JSONFormatter, python-json-logger ou structlog. Associez le contexte (ID de requête, utilisateur) au début d’une opération afin que chaque ligne de journal générée pendant cette opération le conserve.

Questions Fréquemment Posées

La leçon « Journalisation structurée » est-elle gratuite ?

Oui — le texte complet de « Journalisation structurée » 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 « Journalisation structurée » ?

Émettez des journaux au format JSON pour obtenir une sortie lisible par les machines. 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 3 sur 4.

Combien de temps prend la leçon « Journalisation structurée » ?

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