Heartbeat & Monitoring

Das Problem

Wenn ein Agent hängen bleibt oder unkontrolliert Token verbraucht, merkst du es meist erst, wenn die Rechnung kommt. Du brauchst Überwachung.

Heartbeat Pattern

Ein regelmäßiges Signal, das dem System mitteilt: „Ich lebe noch“.

// Heartbeat Loop (Pseudocode)
every 60 seconds:
  status = agent.healthCheck()
  metrics.publish('agent_heartbeat', {
    status: status,
    timestamp: now(),
    uptime: uptime(),
    tokens_used: tokens.total()
  })
  
  if status != 'healthy':
    alert.oncall('Agent unhealthy', status)

Python Implementation

# Heartbeat Service
import asyncio
import time
from datetime import datetime

class Heartbeat:
    def __init__(self, agent_name: str, interval: int = 60):
        self.agent_name = agent_name
        self.interval = interval
        self.last_beat = datetime.now()
        self.status = "healthy"
        
    async def beat(self):
        """Send heartbeat to monitoring"""
        self.last_beat = datetime.now()
        
        # Check Agent Health
        try:
            health = await self.agent.health_check()
            self.status = "healthy" if health else "degraded"
        except:
            self.status = "unhealthy"
            
        # Publish to Prometheus
        metrics.agent_heartbeat.labels(
            agent=self.agent_name,
            status=self.status
        ).inc()
        
    async def run(self):
        """Main heartbeat loop"""
        while True:
            await self.beat()
            await asyncio.sleep(self.interval)
            
    def is_alive(self, timeout: int = 180):
        """Check ob Agent noch lebt"""
        elapsed = (datetime.now() - self.last_beat).total_seconds()
        return elapsed < timeout

# Usage
heartbeat = Heartbeat("jim01", interval=60)
asyncio.create_task(heartbeat.run())

Metriken erfassen

Agent Metrics

• Requests pro Minute
• Durchschnittliche Latenz
• Token-Verbrauch (Input/Output)
• Fehlerrate
• Queue-Länge

System Metrics

• CPU / RAM Auslastung
• GPU Utilization (bei Local Models)
• Disk I/O
• Network Traffic

Alerting Regeln

# Prometheus Alert Rules
groups:
- name: agent-alerts
  rules:
  - alert: AgentDown
    expr: up{job="ai-agent"} == 0
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "Agent {{ $labels.instance }} is down"
      
  - alert: HighTokenUsage
    expr: rate(token_usage_total[1h]) > 1000000
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "High token usage detected"

  - alert: AgentStuck
    expr: time() - agent_last_beat > 300
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Agent {{ $labels.agent }} stuck for > 5min"

Tools

• Grafana + Prometheus: Standard für Metrics
• Uptime Kuma: Einfaches Health-Check Dashboard
• n8n Webhook Monitor: Built-in Error Tracking

Uptime Kuma als einfache Alternative

Nicht jedes Setup braucht Prometheus. Uptime Kuma ist ein Self-hosted Monitoring Tool mit Web-UI, das HTTP-Checks, TCP-Checks und Docker-Container überwachen kann:

# Uptime Kuma als Docker Container
docker run -d \
  --name uptime-kuma \
  --restart=always \
  -p 3001:3001 \
  -v uptime-kuma:/app/data \
  louislam/uptime-kuma:1

# Danach erreichbar unter http://localhost:3001
# Monitors anlegen:
# - HTTP(s) Check auf deine Agent-Endpoints
# - TCP Check auf Ollama Port 11434
# - Docker Container Check (Socket einbinden)

# Notifications konfigurieren:
# - Team-Chat Webhook
# - E-Mail
# - Telegram Bot