Monitoring et logs (Flask)

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 importants.

Dans Flask, la journalisation est souvent gérée avec le module intégré logging, tandis que le monitoring peut être assuré par des outils externes ou des extensions.

Comment ça fonctionne dans Flask

1. Journalisation (Logging)

Utiliser le module logging pour créer des messages de niveau : DEBUG, INFO, WARNING, ERROR, CRITICAL.
Configurer des handlers pour envoyer les logs vers différents supports : fichiers, console, ou services externes (ex. ELK, Graylog).
Ajouter des formatters pour structurer les messages avec timestamp, niveau, module, etc.

2. Monitoring des performances et santé de l’application

Suivre le temps de réponse des routes et la charge serveur.
Surveiller l’usage mémoire et CPU.
Détecter les exceptions non gérées et les erreurs 500.

3. Extensions utiles

Flask-Logging ou Structlog pour une journalisation structurée.
Prometheus-Flask-Exporter pour exposer des métriques de performance.
Sentry pour la collecte des erreurs et leur suivi en temps réel.

4. Intégration dans le code

Ajouter un logger global dans app.py ou __init__.py.
Utiliser logger.info(), logger.error() ou logger.debug() dans les routes ou fonctions critiques.
Coupler avec des notifications ou alertes pour les erreurs critiques.

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.
Utiliser des outils de monitoring externes pour centraliser et visualiser les métriques.

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 sont essentiels pour comprendre le comportement de l’application.
Le monitoring permet de suivre la santé et la performance de Flask en temps réel.
Bien configurer et structurer logs et métriques est la clé pour maintenir une application stable et réactive.

Fonctions :

Monitoring et logs avec Flask

Exemple de code :

from flask import Flask, request
import logging
from datetime import datetime

app = Flask(__name__)

# 1️⃣ Configuration du logging
logging.basicConfig(
    filename='app.log',        # Nom du fichier de log
    level=logging.INFO,         # Niveau de logs à enregistrer
    format='%(asctime)s - %(levelname)s - %(message)s'
)

# 2️⃣ Route d'accueil avec log
@app.route("/")
def home():
    app.logger.info("Route '/' visitée")  # Log d'information
    return "Bienvenue sur la page d'accueil !"

# 3️⃣ Route avec paramètre et log détaillé
@app.route("/user/<username>")
def show_user(username):
    app.logger.info(f"Route '/user/{username}' visitée par {request.remote_addr}")
    return f"Bonjour, {username} !"

# 4️⃣ Route qui déclenche une erreur et log l'exception
@app.route("/error")
def error_route():
    try:
        1 / 0  # Erreur volontaire
    except Exception as e:
        app.logger.error(f"Erreur rencontrée : {e}", exc_info=True)
        return "Une erreur est survenue !", 500

if __name__ == "__main__":
    app.run(debug=True)

Explication du code :

from flask import Flask, request importe la classe Flask pour créer l’application web et request pour accéder aux informations de la requête (comme l’adresse IP du visiteur).
 import logging importe le module standard de Python pour gérer les logs.
 from datetime import datetime importe la classe datetime pour éventuellement ajouter des horodatages personnalisés.
 app = Flask(__name__) crée une instance de l’application Flask.
1️⃣ Configuration du logging
 logging.basicConfig(filename='app.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') configure le logging :
 - filename='app.log' : tous les logs sont enregistrés dans ce fichier.
 - level=logging.INFO : capture les messages d’information et plus graves (INFO, WARNING, ERROR, CRITICAL).
 - format='%(asctime)s - %(levelname)s - %(message)s' : format du message incluant la date, le niveau et le message.
2️⃣ Route d’accueil avec log
 @app.route("/") définit la route principale accessible à http://127.0.0.1:5000/.
 app.logger.info("Route '/' visitée") enregistre dans le log chaque visite de cette route.
 return "Bienvenue sur la page d'accueil !" renvoie le texte au navigateur.
3️⃣ Route avec paramètre dynamique et log détaillé
 @app.route("/user/<username>") définit une route dynamique qui capture le nom d’utilisateur dans l’URL.
 app.logger.info(f"Route '/user/{username}' visitée par {request.remote_addr}") logue le nom de l’utilisateur et son adresse IP.
 return f"Bonjour, {username} !" renvoie un message personnalisé au navigateur.
4️⃣ Route qui déclenche une erreur et log l’exception
 @app.route("/error") définit une route qui provoque volontairement une erreur.
 try: 1 / 0 provoque une division par zéro.
 except Exception as e: capture l’exception.
 app.logger.error(f"Erreur rencontrée : {e}", exc_info=True) enregistre l’erreur dans le log avec la trace complète.
 return "Une erreur est survenue !", 500 renvoie un message d’erreur au navigateur avec le code HTTP 500.
5️⃣ Lancer l’application Flask
 if __name__ == "__main__": vérifie que le fichier est exécuté directement.
 app.run(debug=True) démarre le serveur Flask en mode debug, permettant le rechargement automatique et l’affichage détaillé des erreurs dans la console.