{
  "type": "monitoring.alert",
  "data": {
    "level": "warning",
    "message": "CPU usage is high: 85%",
    "timestamp": "2024-01-13T10:30:00Z",
    "metrics": {
      "system": {
        "cpu_usage": 85,
        "memory_usage": 47.0,
        "disk_usage": 44.2
      }
    }
  }
}

{
  "type": "workflow.status",
  "data": {
    "workflow_id": "wf_123",
    "status": "completed",
    "execution_time": 45.2,
    "timestamp": "2024-01-13T10:30:00Z"
  }
}

{
  "type": "payment.succeeded",
  "data": {
    "payment_id": "pi_123",
    "amount": 2900,
    "currency": "eur",
    "timestamp": "2024-01-13T10:30:00Z"
  }
}

# Configuration système des webhooks
WEBHOOK_ALERTS_ENABLED=true
WEBHOOK_ALERT_RETRY_COUNT=3
WEBHOOK_ALERT_RETRY_DELAY=60
WEBHOOK_ALERT_TIMEOUT=10

import hmac
import hashlib

def verify_webhook_signature(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected)

from fastapi import FastAPI, Request, HTTPException
from fastapi.security import HTTPBearer

app = FastAPI()
security = HTTPBearer()

@app.post("/internal/webhooks/flowz")
async def handle_webhook(request: Request):
    payload = await request.json()
    signature = request.headers.get("X-Flowz-Signature")
    
    if not verify_webhook_signature(
        payload=str(payload),
        signature=signature,
        secret=WEBHOOK_SECRET
    ):
        raise HTTPException(status_code=401)
    
    if payload["type"] == "monitoring.alert":
        await handle_alert(payload["data"])
    
    return {"status": "processed"}

async def handle_alert(alert_data):
    if alert_data["level"] == "critical":
        # Notification immédiate
        await send_urgent_notification(alert_data)
    else:
        # Agrégation des alertes
        await aggregate_alerts(alert_data)

async def deduplicate_alert(alert):
    """Évite les alertes système redondantes dans un intervalle"""
    cache_key = f"alert:{alert['message']}:{alert['level']}"
    if await redis.exists(cache_key):
        return False
    await redis.setex(cache_key, 300, "1")  # TTL 5 minutes
    return True

async def aggregate_alerts(alert):
    """Agrège les alertes système similaires"""
    window_key = f"alerts:{alert['type']}:{datetime.now().strftime('%Y%m%d-%H')}"
    await redis.hincrby(window_key, alert['level'], 1)
    await redis.expire(window_key, 86400)  # TTL 24 heures

{
  "total_webhooks": 5,
  "active_webhooks": 4,
  "delivery_success_rate": 99.8,
  "average_response_time": 0.245,
  "failed_deliveries_24h": 2
}