Multi Site Health Monitor

---

name: multi-site-health-monitor description: "Monitor dozens of websites with configurable health checks, auto-restart alerts, and intelligent alert routing. Use when the user needs uptime tracking, performance monitoring, or automated incident response across multiple domains." version: 1.0.0 homepage: https://github.com/ncreighton/empire-skills metadata: {"openclaw":{"requires":{"env":["SLACK_WEBHOOK_URL","PAGERDUTY_API_KEY","DATADOG_API_KEY"],"bins":["curl","jq"]},"os":["macos","linux","win32"],"files":["SKILL.md"],"emoji":"📡"}}

---

Multi-Site Health Monitor

Overview

The Multi-Site Health Monitor skill automates continuous monitoring of 10-100+ websites with configurable health checks, intelligent alert routing, and automatic incident escalation. This production-grade monitoring solution integrates with Slack, PagerDuty, Datadog, Google Sheets, and WordPress to provide real-time visibility into your digital infrastructure.

Why This Matters

Prevent Revenue Loss: Detect downtime in seconds, not hours

Reduce Alert Fatigue: Smart thresholds and deduplication prevent notification overload

Automate Incident Response: Auto-restart failed services, escalate to on-call teams

Multi-Channel Alerts: Route critical issues to PagerDuty, warnings to Slack, metrics to Datadog

Historical Analysis: Track uptime trends, identify patterns, generate compliance reports

Key Integrations

Slack: Real-time alerts, incident channels, status dashboards

PagerDuty: Automatic incident creation, on-call escalation, incident tracking

Datadog: Metric ingestion, custom dashboards, anomaly detection

Google Sheets: Automated reporting, SLA tracking, audit logs

WordPress: Monitor plugin health, theme updates, core vulnerabilities

AWS/Azure: Auto-restart EC2 instances, trigger Lambda functions, scale infrastructure

---

Quick Start

Try these example prompts immediately:

Example 1: Monitor 5 Critical Sites with Slack Alerts

Monitor these sites every 5 minutes and alert Slack if any fail:
https://api.example.com/health
https://app.example.com/status
https://cdn.example.com/ping
https://wordpress.example.com/wp-json/health
https://db.example.com/check
Alert rules:
Critical (page down): Slack #incidents + PagerDuty
Warning (slow >3s): Slack #alerts
Info (cert expires <30d): Google Sheets log

Example 2: Auto-Restart Failed Services

Monitor https://payment-service.example.com/health every 2 minutes.
If it fails 3 times in a row:
1. POST to https://restart-api.example.com/restart-payment-service
2. Alert PagerDuty with incident "Payment Service Down"
3. Notify Slack #critical-incidents
4. Log to Google Sheets with timestamp, error details, restart status
Response timeout: 10 seconds
Expected response: HTTP 200 with {"status":"healthy"}

Example 3: WordPress Multi-Site Monitoring

Monitor these WordPress sites for health + security:
https://site1.example.com/wp-json/wp/v2/health-check
https://site2.example.com/wp-json/wp/v2/health-check
https://site3.example.com/wp-json/wp/v2/health-check
Check for:
Core updates available (warning if >1 week old)
Plugin vulnerabilities (critical if any)
Database connectivity (critical if down)
SSL certificate expiry (warning if <30 days)
Alert destinations:
Critical: PagerDuty + Slack #wordpress-critical
Warning: Slack #wordpress-alerts
Info: Google Sheets #monitoring-log

Example 4: Performance Threshold Monitoring

Monitor https://api.example.com/metrics every 10 minutes.
Alert if:
Response time > 2000ms (warning) or > 5000ms (critical)
Error rate > 1% (warning) or > 5% (critical)
CPU usage > 70% (warning) or > 90% (critical)
Memory usage > 80% (warning) or > 95% (critical)
Send metrics to Datadog with tags: env:prod, service:api, team:backend

---

Capabilities

1. Multi-Protocol Health Checks

Monitor endpoints via:

HTTP/HTTPS: GET, POST, HEAD requests with custom headers

TCP: Port connectivity checks (e.g., database ports 3306, 5432)

DNS: Domain resolution, DNS propagation verification

SSL/TLS: Certificate validity, expiration warnings, chain verification

Ping/ICMP: Basic connectivity for infrastructure nodes

Example: Monitor API health with custom authentication

Endpoint: https://api.example.com/health
Method: POST
Headers: 
  Authorization: Bearer YOUR_API_KEY
  User-Agent: MultiSiteMonitor/1.0.0
Expected Status: 200
Expected Body: {"status":"healthy","version":"2.1.0"}
Timeout: 10 seconds

2. Intelligent Alert Routing

Severity-Based Routing: Critical → PagerDuty + Slack + SMS, Warning → Slack only, Info → Sheets log

Deduplication: Suppress duplicate alerts within 5-minute window

Escalation Rules: Auto-escalate if critical issue unresolved for 30+ minutes

Custom Thresholds: Define per-endpoint sensitivity (e.g., API endpoint stricter than blog)

Quiet Hours: Suppress non-critical alerts during maintenance windows

3. Automatic Incident Response

Webhook Triggers: POST to custom endpoints (restart services, scale infrastructure)

AWS Integration: Auto-restart EC2 instances, trigger Lambda functions

Service Restart: Execute shell commands on remote servers via SSH

Rollback Triggers: Revert deployments if health checks fail

Notification Actions: Create tickets in Jira, GitHub Issues, or Linear

4. Performance Metrics & Trending

Response Time Tracking: Detect slowdowns before they become critical

Uptime Calculation: Real-time SLA tracking (99.9%, 99.95%, 99.99%)

Error Rate Monitoring: Track HTTP 4xx, 5xx, timeout errors

Datadog Integration: Send custom metrics for dashboards and alerts

Historical Reporting: Generate monthly uptime reports, SLA compliance docs

5. WordPress-Specific Monitoring

Core Updates: Alert when WordPress core updates available

Plugin Vulnerabilities: Check against WordPress vulnerability database

Theme Security: Monitor for outdated or vulnerable themes

Database Health: Monitor wp_options, table integrity, query performance

User Activity: Track suspicious login attempts, new admin accounts

Backup Verification: Confirm backups complete successfully

6. Compliance & Audit Logging

Google Sheets Integration: Automatic logging of all checks, alerts, actions

Audit Trail: Who triggered what, when, and what happened

SLA Reports: Monthly/quarterly compliance reports (99.9% uptime proof)

Change Tracking: Document all configuration changes with timestamps

Export Formats: CSV, JSON, PDF for compliance submissions

---

Configuration

Required Environment Variables

# Slack notifications
export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
export SLACK_CHANNEL="#incidents"  # or #alerts, #monitoring, etc.
PagerDuty incident creation
export PAGERDUTY_API_KEY="YOUR_PAGERDUTY_API_KEY"
export PAGERDUTY_SERVICE_ID="YOUR_SERVICE_ID"
Datadog metrics ingestion
export DATADOG_API_KEY="YOUR_DATADOG_API_KEY"
export DATADOG_APP_KEY="YOUR_DATADOG_APP_KEY"
export DATADOG_SITE="datadoghq.com"  # or datadoghq.eu
Google Sheets logging
export GOOGLE_SHEETS_ID="YOUR_SPREADSHEET_ID"
export GOOGLE_SERVICE_ACCOUNT_JSON="/path/to/service-account.json"
AWS auto-restart (optional)
export AWS_ACCESS_KEY_ID="YOUR_AWS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_AWS_SECRET"
export AWS_REGION="us-east-1"
SSH for remote service restart (optional)
export SSH_PRIVATE_KEY="/path/to/private/key"
export SSH_USER="deploy"

Configuration File Format (YAML)

# monitors.yaml
monitors:
  - name: "Production API"
    url: "https://api.example.com/health"
    interval: 300  # seconds
    timeout: 10
    method: "GET"
    expected_status: 200
    expected_body_contains: "healthy"
    alert_rules:
      critical:
        - slack_channel: "#critical-incidents"
        - pagerduty_severity: "critical"
      warning:
        - slack_channel: "#alerts"
    auto_restart:
      enabled: true
      command: "systemctl restart api-service"
      max_retries: 3
      retry_delay: 60
  - name: "WordPress Site"
    url: "https://wordpress.example.com/wp-json/wp/v2/health-check"
    interval: 600
    timeout: 15
    method: "GET"
    headers:
      Authorization: "Bearer YOUR_WP_TOKEN"
    checks:
      - type: "wordpress_core_updates"
        alert_if: "available"
        severity: "warning"
      - type: "plugin_vulnerabilities"
        alert_if: "found"
        severity: "critical"
      - type: "ssl_certificate"
        expires_in_days: 30
        severity: "warning"
    alert_rules:
      critical:
        - pagerduty_severity: "critical"
        - slack_channel: "#wordpress-critical"
      warning:
        - slack_channel: "#wordpress-alerts"
        - google_sheets: true
  - name: "Database Health"
    url: "https://db-monitor.example.com/health"
    interval: 120
    timeout: 20
    method: "POST"
    headers:
      Content-Type: "application/json"
      Authorization: "Bearer YOUR_DB_TOKEN"
    body: '{"check":"full"}'
    expected_status: 200
    performance_thresholds:
      response_time_ms: 2000
      error_rate_percent: 1.0
    alert_rules:
      critical:
        - pagerduty_severity: "critical"
        - datadog_metric: "db.health.critical"
      warning:
        - datadog_metric: "db.health.warning"
        - slack_channel: "#database-alerts"

Setup Instructions

1. Create monitoring config: Save YAML above as monitors.yaml 2. Set environment variables: Source .env file with all required API keys 3. Initialize Google Sheets: Create spreadsheet, share with service account email 4. Test endpoints: Run multi-site-health-monitor --validate to verify all URLs respond 5. Deploy: Run as systemd service or Docker container for continuous monitoring

---

Example Outputs

Slack Alert (Critical)

🚨 CRITICAL: Production API Down
Service: Production API (api.example.com/health)
Status: HTTP 500 Internal Server Error
Response Time: 12.3s (timeout threshold: 10s)
Last Healthy: 2024-01-15 14:32:15 UTC
Incident Duration: 5 minutes 23 seconds
Alert Count: 3 consecutive failures
Auto-Restart Status: ✅ Triggered (attempt 1/3)
PagerDuty Incident: INC-12345 (assigned to @oncall-backend)
Next Check: 2024-01-15 14:42:15 UTC
Escalation: Will escalate to #management if unresolved in 25 minutes

Google Sheets Log Entry

Timestamp          | Service           | Status | Response Time | Error       | Action Taken
2024-01-15 14:37   | Production API    | FAIL   | 12300ms       | HTTP 500    | Auto-restart triggered
2024-01-15 14:32   | Production API    | FAIL   | 10100ms       | Timeout     | Alert sent
2024-01-15 14:27   | Production API    | OK     | 245ms         | -           | -
2024-01-15 14:22   | WordPress Site    | WARN   | 3200ms        | Slow        | Alert sent
2024-01-15 14:17   | Database Health   | OK     | 145ms         | -           | -

PagerDuty Incident

Incident: INC-12345
Service: Production API
Severity: Critical
Status: Triggered
Title: Production API Down - HTTP 500 (5min+ duration)
Description: 
  Endpoint: https://api.example.com/health
  Status: HTTP 500 Internal Server Error
  Response Time: 12.3s
  Consecutive Failures: 3
  Last Healthy: 2024-01-15 14:32:15 UTC
  Auto-Restart: Triggered (attempt 1/3)
  
Assigned To: @oncall-backend
Created: 2024-01-15 14:37:00 UTC
Escalation Policy: Backend On-Call → Manager → VP Engineering

Datadog Metrics Sent

multi_site_monitor.health_check.response_time:245ms (tags: service:api, env:prod)
multi_site_monitor.health_check.status:200 (tags: service:api, env:prod)
multi_site_monitor.health_check.availability:99.87 (tags: service:api, env:prod)
multi_site_monitor.auto_restart.attempts:1 (tags: service:api, env:prod)

---

Tips & Best Practices

1. Optimal Check Intervals

Critical APIs: 60-120 seconds (detects issues in 2-4 minutes)

Standard Services: 300 seconds (5 minutes, good balance)

Non-Critical Endpoints: 600-900 seconds (10-15 minutes, reduces noise)

Batch Jobs: 1800+ seconds (30+ minutes, less frequent monitoring)

2. Threshold Tuning

Start Conservative: Begin with loose thresholds, tighten over 2 weeks

Account for Variance: Set response time thresholds 2-3x slower than baseline

Error Rate: 0.1-1% warning, 5%+ critical (adjust per service SLA)

Test Thresholds: Deliberately fail endpoints to verify alert routing works

3. Reducing Alert Fatigue

Deduplication: Suppress identical alerts within 5-minute window

Smart Escalation: Only escalate if issue persists >30 minutes

Quiet Hours: Disable non-critical alerts 2am-6am (adjust per timezone)

Severity Mapping: Not everything is critical; use warning/info for minor issues

4. WordPress-Specific Best Practices

Check Core Updates Weekly: Set interval to 604,800 seconds (7 days)

Monitor Plugin Health Daily: Check for vulnerabilities, outdated plugins

Database Backups: Verify backup completion status in health endpoint

Staging Environment: Monitor staging sites separately to catch issues before production

Custom Health Endpoints: Create /wp-json/custom/health returning comprehensive data

5. Cost Optimization

Batch Checks: Group 5-10 checks into single HTTP request where possible

Datadog Sampling: Send detailed metrics every 5 minutes, summary every hour

Google Sheets: Batch writes (max 100 rows per request) to reduce API calls

PagerDuty: Use deduplication to avoid triggering duplicate incidents

6. Security Hardening

API Key Rotation: Rotate all API keys monthly

VPC Monitoring: Monitor internal endpoints from private subnets only

IP Whitelisting: Restrict health check endpoints

Try these example prompts immediately:

Example 1: Monitor 5 Critical Sites with Slack Alerts

Monitor these sites every 5 minutes and alert Slack if any fail:
https://api.example.com/health
https://app.example.com/status
https://cdn.example.com/ping
https://wordpress.example.com/wp-json/health
https://db.example.com/check
Alert rules:
Critical (page down): Slack #incidents + PagerDuty
Warning (slow >3s): Slack #alerts
Info (cert expires <30d): Google Sheets log

Example 2: Auto-Restart Failed Services

Monitor https://payment-service.example.com/health every 2 minutes.
If it fails 3 times in a row:
1. POST to https://restart-api.example.com/restart-payment-service
2. Alert PagerDuty with incident "Payment Service Down"
3. Notify Slack #critical-incidents
4. Log to Google Sheets with timestamp, error details, restart status
Response timeout: 10 seconds
Expected response: HTTP 200 with {"status":"healthy"}

Example 3: WordPress Multi-Site Monitoring

Monitor these WordPress sites for health + security:
https://site1.example.com/wp-json/wp/v2/health-check
https://site2.example.com/wp-json/wp/v2/health-check
https://site3.example.com/wp-json/wp/v2/health-check
Check for:
Core updates available (warning if >1 week old)
Plugin vulnerabilities (critical if any)
Database connectivity (critical if down)
SSL certificate expiry (warning if <30 days)
Alert destinations:
Critical: PagerDuty + Slack #wordpress-critical
Warning: Slack #wordpress-alerts
Info: Google Sheets #monitoring-log

Example 4: Performance Threshold Monitoring

Monitor https://api.example.com/metrics every 10 minutes.
Alert if:
Response time > 2000ms (warning) or > 5000ms (critical)
Error rate > 1% (warning) or > 5% (critical)
CPU usage > 70% (warning) or > 90% (critical)
Memory usage > 80% (warning) or > 95% (critical)
Send metrics to Datadog with tags: env:prod, service:api, team:backend

---

Required Environment Variables

# Slack notifications
export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
export SLACK_CHANNEL="#incidents"  # or #alerts, #monitoring, etc.
PagerDuty incident creation
export PAGERDUTY_API_KEY="YOUR_PAGERDUTY_API_KEY"
export PAGERDUTY_SERVICE_ID="YOUR_SERVICE_ID"
Datadog metrics ingestion
export DATADOG_API_KEY="YOUR_DATADOG_API_KEY"
export DATADOG_APP_KEY="YOUR_DATADOG_APP_KEY"
export DATADOG_SITE="datadoghq.com"  # or datadoghq.eu
Google Sheets logging
export GOOGLE_SHEETS_ID="YOUR_SPREADSHEET_ID"
export GOOGLE_SERVICE_ACCOUNT_JSON="/path/to/service-account.json"
AWS auto-restart (optional)
export AWS_ACCESS_KEY_ID="YOUR_AWS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_AWS_SECRET"
export AWS_REGION="us-east-1"
SSH for remote service restart (optional)
export SSH_PRIVATE_KEY="/path/to/private/key"
export SSH_USER="deploy"

Configuration File Format (YAML)

# monitors.yaml
monitors:
  - name: "Production API"
    url: "https://api.example.com/health"
    interval: 300  # seconds
    timeout: 10
    method: "GET"
    expected_status: 200
    expected_body_contains: "healthy"
    alert_rules:
      critical:
        - slack_channel: "#critical-incidents"
        - pagerduty_severity: "critical"
      warning:
        - slack_channel: "#alerts"
    auto_restart:
      enabled: true
      command: "systemctl restart api-service"
      max_retries: 3
      retry_delay: 60
  - name: "WordPress Site"
    url: "https://wordpress.example.com/wp-json/wp/v2/health-check"
    interval: 600
    timeout: 15
    method: "GET"
    headers:
      Authorization: "Bearer YOUR_WP_TOKEN"
    checks:
      - type: "wordpress_core_updates"
        alert_if: "available"
        severity: "warning"
      - type: "plugin_vulnerabilities"
        alert_if: "found"
        severity: "critical"
      - type: "ssl_certificate"
        expires_in_days: 30
        severity: "warning"
    alert_rules:
      critical:
        - pagerduty_severity: "critical"
        - slack_channel: "#wordpress-critical"
      warning:
        - slack_channel: "#wordpress-alerts"
        - google_sheets: true
  - name: "Database Health"
    url: "https://db-monitor.example.com/health"
    interval: 120
    timeout: 20
    method: "POST"
    headers:
      Content-Type: "application/json"
      Authorization: "Bearer YOUR_DB_TOKEN"
    body: '{"check":"full"}'
    expected_status: 200
    performance_thresholds:
      response_time_ms: 2000
      error_rate_percent: 1.0
    alert_rules:
      critical:
        - pagerduty_severity: "critical"
        - datadog_metric: "db.health.critical"
      warning:
        - datadog_metric: "db.health.warning"
        - slack_channel: "#database-alerts"

Setup Instructions

1. Create monitoring config: Save YAML above as monitors.yaml 2. Set environment variables: Source .env file with all required API keys 3. Initialize Google Sheets: Create spreadsheet, share with service account email 4. Test endpoints: Run multi-site-health-monitor --validate to verify all URLs respond 5. Deploy: Run as systemd service or Docker container for continuous monitoring

---