Monitoring Dragonfly DB with Vigilmon

Dragonfly is a modern open-source in-memory data store designed as a drop-in replacement for Redis and Memcached — with multi-threaded architecture that delivers up to 25x the throughput of Redis on the same hardware. Teams migrate from Redis to Dragonfly to scale their caching and session layers without horizontal sharding. But that high-performance cache layer is also a single point of failure: if Dragonfly goes down, every service that depends on sessions, rate limiting, or queues degrades immediately. Vigilmon gives you proactive alerting across the health endpoint, Redis-compatible port, admin interface, TLS certificates, and replication health.

What You'll Set Up

• HTTP monitor for the Dragonfly /health endpoint
• TCP port monitor for the Redis-compatible port (6379)
• HTTP monitor for the Dragonfly admin HTTP port
• SSL certificate alerts for TLS-secured Dragonfly deployments
• Heartbeat monitor for Dragonfly replication health checks

Prerequisites

• Dragonfly 1.x running on a Linux host (single instance or replica set)
• HTTP admin port accessible (default: 6379 for admin HTTP on non-TLS, see Step 3)
• A free Vigilmon account

Step 1: Monitor the Dragonfly HTTP Health Endpoint

Dragonfly exposes an HTTP health endpoint at /health on its admin port. The endpoint returns HTTP 200 when the server is ready to serve requests.

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter http://your-dragonfly-host:6379/health.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Verify manually:

curl -s -o /dev/null -w "%{http_code}" http://localhost:6379/health
# 200

Dragonfly's HTTP admin server runs on the same port as the Redis protocol by default (--port 6379). The /health path is HTTP-only — Redis clients connect via the Redis protocol on the same port and are not affected.

If you run Dragonfly with a separate admin port (--admin_port):

dragonfly --port 6379 --admin_port 9999

Then use http://your-host:9999/health for the health monitor.

Step 2: Monitor the Redis-Compatible TCP Port

Dragonfly is wire-compatible with Redis. All Redis clients (redis-cli, Jedis, ioredis, redis-py) connect on port 6379. A TCP port monitor confirms the data plane is reachable.

1. Click Add Monitor → TCP Port.
2. Enter your Dragonfly host IP and port 6379.
3. Set Check interval to 1 minute.
4. Click Save.

Verify the port is listening:

redis-cli -h your-dragonfly-host -p 6379 PING
# PONG

Or with nc:

nc -z your-dragonfly-host 6379 && echo "Port open" || echo "Port closed"

If Dragonfly is TLS-enabled (--tls, --tls_port), add a TCP monitor on the TLS port as well:

redis-cli -h your-dragonfly-host -p 6380 --tls PING
# PONG

Step 3: Monitor the Dragonfly Admin HTTP Port

Dragonfly's admin HTTP interface exposes metrics, configuration, and management endpoints beyond /health. If you've configured a separate --admin_port, monitor it as an independent service.

1. Click Add Monitor → HTTP / HTTPS.
2. Enter http://your-dragonfly-host:9999/ (replace 9999 with your configured admin port).
3. Set Expected HTTP status to 200.
4. Set Check interval to 1 minute.
5. Click Save.

Useful admin endpoints to explore:

# Prometheus-format metrics
curl http://localhost:9999/metrics

# Server info (similar to Redis INFO)
curl http://localhost:9999/info

# Flags and configuration
curl http://localhost:9999/flags

If your load balancer or reverse proxy sits in front of Dragonfly's admin interface, monitor the proxied URL instead and add SSL monitoring to the proxy's certificate.

Step 4: SSL Certificate Alerts for TLS-Secured Dragonfly

TLS on Dragonfly protects data in transit for both the Redis protocol and the HTTP admin interface. An expired certificate causes all clients to fail with TLS handshake errors — often surfacing as application errors that look unrelated to the cache layer.

Enable TLS in Dragonfly's startup flags:

dragonfly \
  --tls \
  --tls_port 6380 \
  --tls_cert_file /etc/dragonfly/cert.pem \
  --tls_key_file /etc/dragonfly/key.pem

Add the SSL certificate monitor in Vigilmon:

1. Create an HTTPS HTTP monitor pointing to your TLS endpoint (e.g. https://your-dragonfly-host:6380 via an HTTPS wrapper, or the admin HTTPS port if configured).
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

Check certificate expiry from the command line:

# Check TLS port directly
openssl s_client -connect your-dragonfly-host:6380 </dev/null 2>/dev/null \
  | openssl x509 -noout -dates
# notBefore=...
# notAfter=Jan  1 00:00:00 2026 GMT

# Check the cert file directly
openssl x509 -noout -dates -in /etc/dragonfly/cert.pem

If you manage certificates with certbot, verify the renewal timer:

systemctl status certbot.timer
certbot certificates | grep -A2 dragonfly

Step 5: Heartbeat Monitoring for Dragonfly Replication Health

Dragonfly supports Redis-compatible replication (primary + replicas). A replica can fall behind or disconnect while the primary remains healthy — the /health endpoint won't show this. A heartbeat script that writes to the primary and reads from a replica catches replication lag and silent disconnects.

1. In Vigilmon, click Add Monitor → Cron Heartbeat.
2. Set the expected ping interval to 5 minutes.
3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Create a replication health check script:

#!/usr/bin/env python3
# dragonfly_heartbeat.py
import redis
import time
import requests
import sys

HEARTBEAT_URL = "https://vigilmon.online/heartbeat/abc123"
PRIMARY_HOST = "primary.dragonfly.internal"
REPLICA_HOST = "replica.dragonfly.internal"
PORT = 6379
TEST_KEY = "vigilmon:health:check"
MAX_REPLICATION_LAG_S = 5.0

try:
    primary = redis.Redis(host=PRIMARY_HOST, port=PORT, socket_timeout=5)
    replica = redis.Redis(host=REPLICA_HOST, port=PORT, socket_timeout=5)

    # Write to primary
    ts = str(time.time())
    primary.set(TEST_KEY, ts, ex=60)

    # Wait for replication and read from replica
    deadline = time.time() + MAX_REPLICATION_LAG_S
    replicated_value = None
    while time.time() < deadline:
        val = replica.get(TEST_KEY)
        if val and val.decode() == ts:
            replicated_value = val
            break
        time.sleep(0.2)

    if not replicated_value:
        print(f"ERROR: replica did not reflect primary write within {MAX_REPLICATION_LAG_S}s",
              file=sys.stderr)
        # Check replication info
        info = replica.info('replication')
        print(f"Replica role: {info.get('role')}, master_link_status: {info.get('master_link_status')}",
              file=sys.stderr)
        sys.exit(1)

    # Replication is healthy — ping Vigilmon
    resp = requests.get(HEARTBEAT_URL, timeout=10)
    resp.raise_for_status()
    print(f"OK: replication healthy, lag < {MAX_REPLICATION_LAG_S}s")

except redis.ConnectionError as e:
    print(f"ERROR: connection failed: {e}", file=sys.stderr)
    sys.exit(1)

For a single-node deployment without replicas, simplify to a write/read round-trip on the same instance:

primary.set(TEST_KEY, ts, ex=60)
assert primary.get(TEST_KEY).decode() == ts

Install dependencies and schedule:

pip3 install redis requests
crontab -e
# Add:
*/5 * * * * /usr/bin/python3 /usr/local/bin/dragonfly_heartbeat.py >> /var/log/dragonfly-heartbeat.log 2>&1

If the primary is unreachable, the write fails. If the replica has disconnected, the read returns stale data. Either way, the heartbeat ping is not sent and Vigilmon fires an alert.

Summary

| Monitor | Type | Target | Interval | |---|---|---|---| | HTTP health endpoint | HTTP | host:6379/health | 1 min | | Redis-compatible port | TCP Port | host:6379 | 1 min | | Admin HTTP port | HTTP | host:9999/ | 1 min | | SSL certificate | SSL | TLS endpoint | 1 day | | Replication health | Heartbeat | /heartbeat/abc123 | 5 min |

Five monitors cover the full Dragonfly stack — from the HTTP health plane through the Redis data port to TLS hygiene and replication correctness. When any layer fails, Vigilmon alerts you before your applications start seeing cache misses or stale data.

Set up your free Vigilmon account at vigilmon.online and have Dragonfly monitoring live in under 10 minutes.