Monitoring et logs (Fast API)

Le monitoring et les logs permettent de suivre le comportement de l’application, détecter les erreurs, analyser les performances et conserver un historique des événements.

FastAPI, étant basé sur Starlette, offre des mécanismes de journalisation intégrés et peut facilement être intégré avec des outils externes pour le monitoring en production.

Comment ça fonctionne dans FastAPI

1. Journalisation (Logging)

Utiliser le module logging de Python pour générer des messages de niveau : DEBUG, INFO, WARNING, ERROR, CRITICAL.
Configurer des handlers pour envoyer les logs vers des fichiers, la console ou des services externes.
Structurer les messages avec formatters pour inclure timestamp, niveau, module, etc.

2. Middleware et suivi des requêtes

FastAPI permet de créer des middlewares pour enregistrer des informations sur chaque requête : méthode, URL, temps de traitement, statut HTTP.
Ces informations sont utiles pour détecter les routes lentes ou les erreurs fréquentes.

3. Extensions et outils utiles

Sentry pour collecter et centraliser les erreurs en temps réel.
Prometheus / Grafana pour exposer et visualiser les métriques de performance.
Loguru pour une journalisation simplifiée et colorée.

4. Intégration dans le code

Créer un logger global dans main.py ou un module logger.py.
Utiliser logger.info(), logger.error() ou logger.debug() dans les routes ou fonctions critiques.
Coupler avec un middleware ou des alertes pour surveiller les erreurs et les temps de réponse.

Bonnes pratiques

Séparer les logs applicatifs des logs serveur pour une meilleure lisibilité.
Ne jamais loguer de données sensibles (mots de passe, informations personnelles).
Définir un niveau de log adapté selon l’environnement : DEBUG en développement, WARNING ou ERROR en production.
Centraliser les métriques et logs pour faciliter la supervision.

Pourquoi c’est important

Facilite le débogage et la maintenance de l’application.
Permet de détecter rapidement les erreurs et anomalies en production.
Fournit un historique d’événements pour l’audit ou l’analyse de performance.

En résumé

Les logs et le monitoring sont essentiels pour comprendre le comportement de l’application.
FastAPI permet d’intégrer facilement des outils pour surveiller la santé et les performances en temps réel.

Fonctions :

Monitoring et logs avec Fast API

Exemple de code :

from fastapi import FastAPI, Request
import logging
import time

# Configuration des logs
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

app = FastAPI()

# Middleware pour mesurer le temps de traitement de chaque requête
@app.middleware("http")
async def log_requests(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    logging.info(f"{request.method} {request.url} - {process_time:.3f}s")
    return response

@app.get("/")
def read_root():
    logging.info("Route / visitée")
    return {"message": "Bienvenue sur FastAPI !"}

@app.get("/items/{item_id}")
def read_item(item_id: int):
    logging.info(f"Route /items/{item_id} visitée")
    return {"item_id": item_id}

Explication du code :

from fastapi import FastAPI, Request importe FastAPI pour créer l’application et Request pour accéder aux informations des requêtes HTTP.
 import logging importe le module logging pour gérer l’écriture des logs.
 import time importe le module time pour mesurer la durée de traitement des requêtes.
Configuration des logs
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s") configure le niveau de log à INFO et définit un format affichant la date/heure, le niveau et le message.
Créer l’application FastAPI
 app = FastAPI() crée une instance de l’application FastAPI.
Middleware pour mesurer le temps de traitement
 @app.middleware("http") définit un middleware appliqué à toutes les requêtes HTTP.
 async def log_requests(request: Request, call_next): définit une fonction middleware qui reçoit la requête et la passe à la route suivante via call_next.
 start_time = time.time() enregistre le temps au début du traitement.
 response = await call_next(request) appelle la route correspondante et attend la réponse.
 process_time = time.time() - start_time calcule le temps écoulé pour traiter la requête.
 logging.info(f"{request.method} {request.url} - {process_time:.3f}s") écrit un log avec la méthode HTTP, l’URL et la durée en secondes.
 return response renvoie la réponse finale au client.
Routes de l’application
 @app.get("/") définit la route racine accessible à /.
 logging.info("Route / visitée") log l’accès à cette route.
 return {"message": "Bienvenue sur FastAPI !"} renvoie un message JSON.
 @app.get("/items/{item_id}") définit une route avec un paramètre dynamique item_id.
 logging.info(f"Route /items/{item_id} visitée") log l’accès avec l’identifiant de l’item.
 return {"item_id": item_id} renvoie l’ID de l’item dans la réponse JSON.