Monitoring et debugging de workflows

Section 11.3.18 : Monitoring et debugging de workflows

🎯 Objectif pédagogique

Mettre en place le monitoring, le logging et le debugging de vos automatisations. Vous serez capable de diagnostiquer les pannes, de tracer les exécutions, et de maintenir des workflows fiables en production.

Les automatisations cassent — c'est inévitable

Marc a configuré 5 scénarios Make et 3 scripts Python automatisés. Tout fonctionne… jusqu'au jour où ça casse silencieusement. Une API change son format, un token expire, un Google Sheet est renommé. Sans monitoring, vous ne saurez pas que ça ne marche plus.

Monitoring dans Make

Dashboard Make → Scenarios → Votre scénario

🟢 Historique des exécutions :
- Date, durée, nb d'opérations, statut (success/error)
- Cliquez sur une exécution pour voir chaque module

❌ Quand un scénario échoue :
1. Email automatique de Make (si activé dans les paramètres)
2. Le module en erreur est surligné en rouge
3. Cliquez dessus → voir l'erreur exacte

⚙️ Paramètres de monitoring :
- Notifications email → Activez "Error notifications"
- Incomplete executions → Stockées 30 jours
- Data store → Sauvegarder les erreurs pour analyse

Logging en Python

# logger.py — Système de logging pour les scripts Python
import logging
from datetime import datetime
from pathlib import Path

def setup_logger(name, log_file=None, level=logging.INFO):
    """Configurer un logger avec sortie fichier et console."""
    logger = logging.getLogger(name)
    logger.setLevel(level)
    
    # Format détaillé
    formatter = logging.Formatter(
        '%(asctime)s | %(name)s | %(levelname)s | %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    
    # Console handler
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(formatter)
    logger.addHandler(console_handler)
    
    # File handler
    if log_file:
        log_path = Path(log_file)
        log_path.parent.mkdir(exist_ok=True)
        file_handler = logging.FileHandler(str(log_path), encoding='utf-8')
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)
    
    return logger

# Utilisation dans le Job Tracker
logger = setup_logger('job_tracker', 'logs/job_tracker.log')

def add_application_with_logging(company, position, **kwargs):
    """Ajouter une candidature avec logging."""
    logger.info(f"Adding application: \{position\} at \{company\}")
    
    try:
        app_id = add_application(company, position, **kwargs)
        logger.info(f"Application added successfully: ID=\{app_id\}")
        return app_id
    except Exception as e:
        logger.error(f"Failed to add application: \{e\}", exc_info=True)
        raise

Alertes automatiques sur erreur

# alerts.py — Envoi d'alertes quand un workflow échoue
import functools
import traceback
from datetime import datetime

def alert_on_failure(func):
    """Décorateur qui envoie une alerte si la fonction échoue."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        try:
            result = func(*args, **kwargs)
            logger.info(f"\{func.__name__\} completed successfully")
            return result
        except Exception as e:
            error_msg = traceback.format_exc()
            logger.error(f"\{func.__name__\} FAILED: \{error_msg\}")
            
            # Envoyer une alerte (email, Slack, etc.)
            send_alert(
                title=f"🚨 Workflow FAILED: \{func.__name__\}",
                body=f"Erreur : \{str(e)\}\n\nStack trace :\n\{error_msg\}",
                severity="high"
            )
            raise
    return wrapper

def send_alert(title, body, severity="medium"):
    """Envoyer une alerte via le canal approprié."""
    # Option 1 : Webhook Make/Zapier
    import requests
    webhook_url = os.environ.get("ALERT_WEBHOOK_URL")
    if webhook_url:
        requests.post(webhook_url, json=\{
            "title": title,
            "body": body,
            "severity": severity,
            "timestamp": datetime.now().isoformat()
        \}, timeout=10)
    
    # Option 2 : Log local (toujours)
    logger.critical(f"ALERT [\{severity\}]: \{title\}")

# Utilisation :
@alert_on_failure
def daily_job_search():
    """Recherche quotidienne d'offres — alerter si ça échoue."""
    # ... code de recherche ...
    pass

Checklist de monitoring

✅ Pour chaque automatisation en production :

1. LOGGING
   □ Chaque exécution est loggée (début, fin, résultat)
   □ Les erreurs incluent le stack trace complet
   □ Les logs sont datés et identifiables

2. ALERTES
   □ Email/Slack en cas d'erreur
   □ Seuil d'alerte (ex: > 3 erreurs en 1h)
   □ Alerte si l'automatisation ne s'exécute PAS (absence = problème)

3. METRICS
   □ Nombre d'exécutions/jour
   □ Taux de succès
   □ Temps d'exécution moyen
   □ Nombre d'opérations consommées (Make/Zapier)

4. MAINTENANCE
   □ Vérifier les tokens/credentials chaque mois
   □ Tester manuellement les workflows chaque semaine
   □ Documenter les dépendances (APIs, accounts, permissions)

🏋️ Exercice pratique (20 minutes)

1. →Ajoutez le logging au Job Tracker (logger.py)
2. →Wrappez la fonction add_application avec le décorateur @alert_on_failure
3. →Provoquez une erreur (ex: None comme company) et vérifiez le log
4. →Consultez le fichier logs/job_tracker.log