Monitoring Redash with Vigilmon

Redash lets data teams write SQL and build dashboards without a data engineering team standing in the way. But Redash's architecture — a Flask web process, Celery workers, and a Redis queue — means there are multiple independent components that can fail while others keep running. A crashed Celery worker silently stops refreshing query results while the web dashboard looks perfectly healthy. Vigilmon monitors every Redash layer: the ping endpoint, dashboard UI, worker health API, and SSL certificates, so stale data gets caught before it ships to a stakeholder.

What You'll Set Up

• HTTP monitor for the /ping liveness endpoint
• Web dashboard availability check
• Worker health monitoring via /status.json
• SSL certificate expiry alerts
• Heartbeat check for scheduled query refreshes

Prerequisites

• Redash 10+ running (Docker Compose recommended)
• A free Vigilmon account

Step 1: Monitor the /ping Endpoint

Redash exposes /ping as a minimal liveness probe. It returns pong when the Flask web process is alive and accepting connections — no database or worker dependency.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the URL: https://redash.yourdomain.com/ping
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Under Response body, set Contains to pong.
7. Click Save.

This catches the web process being down. It does not catch worker failures — that requires the next two steps.

Step 2: Monitor the Web Dashboard

The /ping endpoint is a raw liveness check, not a user experience check. Monitor the actual dashboard page to catch proxy misconfigurations or authentication middleware errors.

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://redash.yourdomain.com/
3. Set Expected HTTP status to 200.
4. Set Check interval to 2 minutes.
5. Under Response body, set Contains to Redash.
6. Click Save.

Step 3: Worker Health via /status.json

Redash exposes /status.json (admin authentication required in newer versions) with Celery worker counts, queue depths, and Redis connection status. This is the single endpoint that tells you whether background query execution is actually working.

For self-hosted Redash instances where you control network access, set up a Vigilmon monitor with your admin credentials:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://redash.yourdomain.com/status.json
3. Set Expected HTTP status to 200.
4. Under Request headers, add:

   Cookie: session=<your-admin-session-cookie>
   

5. Under Response body, set Contains to "workers" to verify the worker section is present.
6. Set Check interval to 2 minutes.
7. Click Save.

A healthy /status.json response includes:

{
  "workers": ["celery@worker1"],
  "redis_status": "healthy",
  "database_status": "healthy",
  "queues": {"queries": {"size": 0}, "scheduled_queries": {"size": 0}}
}

If workers is an empty array, Celery is down and scheduled queries are not running. Vigilmon will alert when the response body no longer contains "workers" with actual entries.

Alternatively, expose a lightweight internal health proxy on a non-authenticated port within your private network and point Vigilmon at that.

Step 4: SSL Certificate Alerts

Redash dashboards are often embedded in internal tools and shared via public URLs — a certificate expiry breaks access for everyone.

1. Open the HTTP monitor created in Step 1.
2. Enable Monitor SSL certificate under the SSL section.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

If Redash is served on multiple subdomains (e.g. redash.internal.com and a public alias), add a monitor for each hostname.

Step 5: Heartbeat Monitoring for Scheduled Query Refreshes

Redash's scheduled queries refresh on a set interval — every hour, every day, etc. If Celery workers are down or Redis queue depth spikes, scheduled refreshes silently stop. Downstream dashboards show stale data with no warning.

Add a heartbeat that pings Vigilmon after each successful scheduled query run:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected interval to match your most critical scheduled query (e.g. 60 minutes for an hourly revenue report).
3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/abc123

In Redash, add a post-execution script using a Redash query that runs via the API and sends the heartbeat on success:

#!/bin/bash
# Trigger a specific Redash query and ping Vigilmon on success
QUERY_ID=42
RESULT=$(curl -s \
  -H "Authorization: Key $REDASH_API_KEY" \
  "https://redash.yourdomain.com/api/queries/$QUERY_ID/results" \
  -d '{}' \
  -X POST)

if echo "$RESULT" | grep -q '"status":"done"'; then
  curl -s https://vigilmon.online/heartbeat/abc123
fi

Schedule this script as a system cron job matching the Redash query's refresh interval. If workers hang and the query never completes, the heartbeat never pings, and Vigilmon alerts.

Step 6: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. On the /ping monitor, set Consecutive failures to 2 — Docker container restarts can cause brief gaps.
3. On the /status.json worker monitor, set Consecutive failures to 1 — a missing worker is immediately impactful.
4. Consider setting up a dedicated #data-ops Slack channel for Redash alerts, separate from general infrastructure alerts.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Ping liveness | /ping | Web process crash | | Dashboard UI | / | Proxy failure, frontend errors | | Worker health | /status.json | Celery worker down, Redis disconnect | | SSL certificate | Each Redash hostname | Certificate expiry | | Cron heartbeat | Heartbeat URL | Scheduled query staleness, worker hang |

Redash's multi-process architecture means a partial failure is the most common failure mode — the web UI stays green while workers silently stop processing. Vigilmon's layered checks catch both surfaces, keeping your data team confident that scheduled refreshes are running and dashboards are showing current data.