┌──────────────────────────────────────────────┐
│              MONITORING LAYERS                │
│                                               │
│  Layer 1: EXECUTION ALERTS                    │
│  → Know when individual workflows fail        │
│                                               │
│  Layer 2: HEARTBEAT MONITORING                │
│  → Know when scheduled workflows DIDN'T run   │
│                                               │
│  Layer 3: PERFORMANCE TRACKING                │
│  → Know when workflows are slow or degraded   │
│                                               │
│  Layer 4: DAILY DIGEST                        │
│  → Summary of all automation activity         │
│                                               │
│  Alert Channels: Slack → Email → WhatsApp     │
└──────────────────────────────────────────────┘

SETUP:

1. Create a new workflow: "Error Handler — Master Alert"
2. Trigger: Error Trigger node
3. This node receives:
   - $json.execution.id — the failed execution ID
   - $json.execution.url — direct link to the execution
   - $json.workflow.id — which workflow failed
   - $json.workflow.name — workflow name
   - $json.execution.error.message — what went wrong
   - $json.execution.error.node.name — which node failed

4. Connect to your alert channel (Slack, Email, WhatsApp)

5. Assign this workflow as the Error Workflow:
   Settings → Error Workflow → Select "Error Handler — Master Alert"
   Do this for EVERY production workflow

[Error Trigger]
    │
    ▼
[Set Node: Format alert data]
    workflow_name = {{$json.workflow.name}}
    error_msg = {{$json.execution.error.message}}
    failed_node = {{$json.execution.error.node.name}}
    exec_url = {{$json.execution.url}}
    timestamp = {{$now.format('YYYY-MM-DD HH:mm:ss')}}
    │
    ▼
[Switch Node: Severity classification]
    │
    ├── Contains "rate limit" or "429" → SEVERITY: WARNING
    ├── Contains "timeout" → SEVERITY: WARNING
    ├── Contains "unauthorized" or "401" → SEVERITY: CRITICAL
    ├── Contains "payment" or "order" → SEVERITY: CRITICAL
    └── Default → SEVERITY: ERROR
    │
    ▼
[Slack: Post to #automation-alerts]
    │
    ▼
[IF: CRITICAL severity]
    │
    ├── YES → [Gmail: Email alert]
    │         [WhatsApp: Urgent alert to phone]
    │
    └── NO → [Done — Slack is enough]

Slack Block Kit Message:

🔴 *Workflow Failure Alert*

*Workflow:* {{$json.workflow_name}}
*Failed Node:* {{$json.failed_node}}
*Error:* {{$json.error_msg}}
*Severity:* {{$json.severity}}
*Time:* {{$json.timestamp}}

<{{$json.exec_url}}|View Execution in n8n>

CONCEPT:
Every important workflow sends a "heartbeat" after successful completion.
A separate monitor checks if heartbeats arrived on time.

IMPLEMENTATION:

Step 1: Add heartbeat to every critical workflow
[End of workflow] → [Google Sheets: Log heartbeat]
    Row: workflow_name | status: "OK" | timestamp

Step 2: Heartbeat Monitor (runs every hour)
[Schedule Trigger: Every 1 hour]
    │
    ▼
[Google Sheets: Read heartbeat log]
    │
    ▼
[Function Node: Check for missing heartbeats]

    // Define expected schedules
    const schedules = {
      "Order Sync": 15,      // should run every 15 min
      "Daily Report": 1440,  // should run every 24 hours
      "Inventory Check": 360  // should run every 6 hours
    };

    const now = new Date();
    const missing = [];

    for (const item of $input.all()) {
      const name = item.json.workflow_name;
      const lastRun = new Date(item.json.timestamp);
      const expectedInterval = schedules[name];

      if (!expectedInterval) continue;

      const minutesSince = (now - lastRun) / 60000;
      if (minutesSince > expectedInterval * 1.5) {
        missing.push({
          workflow: name,
          last_seen: item.json.timestamp,
          minutes_overdue: Math.round(minutesSince - expectedInterval)
        });
      }
    }

    return missing.length > 0
      ? missing.map(m => ({ json: m }))
      : [{ json: { status: "all_healthy" } }];
    │
    ▼
[IF: missing workflows found]
    │
    ├── YES → [Slack: Alert — workflows are not running]
    └── NO  → [Done — all healthy]

Track how long each workflow takes:

[Start of workflow]
    │
    ▼
[Set: start_time = {{$now.toMillis()}}]
    │
    ▼
[... your workflow nodes ...]
    │
    ▼
[Set: end_time = {{$now.toMillis()}}]
[Set: duration_ms = {{$json.end_time - $json.start_time}}]
[Set: duration_sec = {{Math.round($json.duration_ms / 1000)}}]
    │
    ▼
[Google Sheets: Log performance]
    Columns: workflow_name | duration_sec | items_processed | timestamp
    │
    ▼
[IF: duration_sec > threshold (e.g., 120 seconds)]
    │
    ├── YES → [Slack: Performance warning — workflow took {{duration_sec}}s]
    └── NO  → [Done]

For batch workflows, track throughput:

[After batch processing]
    │
    ▼
[Set Node]
    items_total = {{$json.items.length}}
    items_success = {{$json.items.filter(i => !i.error).length}}
    items_failed = {{$json.items.filter(i => i.error).length}}
    success_rate = {{Math.round(items_success / items_total * 100)}}%
    │
    ▼
[IF: success_rate < 90%]
    │
    ├── YES → [Alert: High failure rate in batch — {{success_rate}}%]
    └── NO  → [Log to performance sheet]

[Schedule Trigger: Daily at 9 AM PKT]
    │
    ▼
[Google Sheets: Read last 24h of heartbeat logs]
    │
    ▼
[Google Sheets: Read last 24h of performance logs]
    │
    ▼
[Function Node: Compile digest]

    const heartbeats = $input.first().json.heartbeats;
    const performance = $input.first().json.performance;

    const totalRuns = heartbeats.length;
    const failures = heartbeats.filter(h => h.status === "FAILED").length;
    const avgDuration = performance.reduce((a, b) =>
      a + b.duration_sec, 0) / performance.length;

    return [{
      json: {
        total_executions: totalRuns,
        failures: failures,
        success_rate: Math.round((totalRuns - failures) / totalRuns * 100),
        avg_duration_sec: Math.round(avgDuration),
        slowest: performance.sort((a, b) =>
          b.duration_sec - a.duration_sec)[0]
      }
    }];
    │
    ▼
[Slack/Email: Send daily digest]

📊 *Automation Daily Digest — {{$now.format('YYYY-MM-DD')}}*

*Overall Health:* ✅ Healthy / ⚠️ Degraded / 🔴 Issues

*Executions:* {{total}} runs ({{success_rate}}% success)
*Failures:* {{failures}} ({{failure_details}})
*Avg Duration:* {{avg_duration}}s
*Slowest:* "{{slowest_name}}" took {{slowest_duration}}s

*Workflows Summary:*
✅ Order Sync — 96 runs, 0 failures
✅ Daily Report — 1 run, OK
⚠️ Inventory Check — 4 runs, 1 timeout (retried OK)
✅ Lead Nurture — 24 runs, 0 failures

*Action Items:*
- None / [List any manual interventions needed]

1. Go to api.slack.com/apps → Create New App
2. From Scratch → Name: "n8n Alerts" → Select workspace
3. OAuth & Permissions → Add scopes:
   - chat:write
   - chat:write.public
4. Install to Workspace → Copy Bot Token (xoxb-...)
5. In n8n: Credentials → Add → Slack API
   → Paste the Bot Token
6. Create a #automation-alerts channel in Slack
7. Invite the bot: /invite @n8n Alerts

[HTTP Request: WATI API]
    Method: POST
    URL: https://live-server.wati.io/api/v1/sendTemplateMessage
    Headers:
      Authorization: Bearer {{$env.WATI_API_KEY}}
    Body:
      {
        "template_name": "automation_alert",
        "broadcast_name": "n8n_alert",
        "receivers": [
          {
            "whatsappNumber": "923001234567",
            "customParams": [
              { "name": "workflow", "value": "{{$json.workflow_name}}" },
              { "name": "error", "value": "{{$json.error_msg}}" }
            ]
          }
        ]
      }