Monitoring Drone CI with Vigilmon: Web UI, Build API, Runner Connectivity, Queue Backlog & SSL Alerts

Drone CI is a lightweight, container-native continuous integration platform that you run entirely on your own infrastructure. Every push to your codebase triggers Drone to spin up containers and run your pipeline — as long as Drone is up. When the Drone server crashes or a runner agent disconnects, pipelines queue silently or fail without notification. Vigilmon gives you the external monitoring layer that Drone doesn't include: uptime checks, health endpoint validation, build API monitoring, queue backlog detection, runner connectivity signals, and SSL certificate alerts.

What You'll Build

• An HTTP monitor for the Drone web UI and health endpoint
• A build API check via Drone's /api/builds route
• A runner agent connectivity heartbeat
• A queue backlog heartbeat to catch stuck pipelines
• Webhook endpoint health monitoring
• SSL certificate expiry alerts
• A pipeline execution heartbeat for end-to-end CI verification

Prerequisites

• Drone server installed and running (Docker or binary deployment)
• At least one Drone runner registered and active
• A domain configured for your Drone server with HTTPS
• A free account at vigilmon.online

Step 1: Monitor the Drone Web UI

The Drone dashboard is where developers view pipeline status, logs, and build history. A down dashboard means your team is flying blind on build status:

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://drone.yourdomain.com
3. Check interval: 120 seconds.
4. Expected status: 200.
5. Label: Drone Web UI
6. Click Save.

Drone's root path serves the React frontend. A 200 response confirms the server process is alive and your reverse proxy is routing traffic correctly to the Drone container.

Step 2: Check the Drone Health Endpoint

Drone exposes /healthz — a dedicated health check route that validates the server's internal state including database connectivity:

1. Add Monitor → HTTP.
2. URL: https://drone.yourdomain.com/healthz
3. Check interval: 60 seconds.
4. Expected status: 200.
5. Keyword: OK (confirms the response body matches Drone's healthy status string).
6. Label: Drone Health
7. Click Save.

The /healthz endpoint is more reliable than a UI check because it bypasses frontend caching. If the Drone database connection drops, /healthz returns a non-200 immediately while the React frontend may still load from cache — making this your primary alert signal.

Step 3: Monitor the Build API

Drone's /api/builds endpoint returns recent build history for a repository and is a reliable proxy for the API layer's health. It requires authentication but confirms that the API router, database queries, and authentication middleware are all functional:

curl -H "Authorization: Bearer YOUR_DRONE_TOKEN" \
  "https://drone.yourdomain.com/api/builds?latest=true&limit=1"
# Returns JSON array of recent builds

Set up a server-side script that calls this endpoint and sends a heartbeat on success:

#!/bin/bash
# /etc/cron.d/drone-api-check — runs every 5 minutes

STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer YOUR_DRONE_TOKEN" \
  "https://drone.yourdomain.com/api/builds?latest=true&limit=1")

if [ "$STATUS" = "200" ]; then
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-API-HEARTBEAT-ID
fi

In Vigilmon:

1. Add Monitor → Heartbeat.
2. Expected interval: 5 minutes.
3. Grace period: 15 minutes.
4. Label: Drone Build API

Step 4: Monitor Queue Backlog

A growing pipeline queue means builds are not being processed — runners are overwhelmed, disconnected, or the server is failing to dispatch work. Monitor the queue via Drone's API:

curl -H "Authorization: Bearer YOUR_DRONE_TOKEN" \
  https://drone.yourdomain.com/api/queue

Create a script that alerts when the pending count grows too large:

#!/bin/bash
# /etc/cron.d/drone-queue-check — runs every 3 minutes

PENDING=$(curl -s -H "Authorization: Bearer YOUR_DRONE_TOKEN" \
  https://drone.yourdomain.com/api/queue | python3 -c \
  "import sys,json; q=json.load(sys.stdin); print(len([i for i in q if i.get('status')=='pending']))" 2>/dev/null || echo "999")

if [ "$PENDING" -lt 10 ] 2>/dev/null; then
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-QUEUE-HEARTBEAT-ID
fi

In Vigilmon:

1. Add Monitor → Heartbeat.
2. Expected interval: 3 minutes.
3. Grace period: 10 minutes.
4. Label: Drone Queue Backlog

When queue depth exceeds 10 pending builds, the heartbeat stops and Vigilmon alerts — a signal that runners are overwhelmed or all have disconnected.

Step 5: Monitor the Webhook Endpoint

Drone receives webhooks from GitHub, Gitea, or Forgejo to trigger pipelines on new commits and pull requests. If the webhook endpoint is unreachable, new code pushes silently fail to trigger any builds:

1. Add Monitor → HTTP.
2. URL: https://drone.yourdomain.com/hook
3. Expected status: 405 (Method Not Allowed for a GET — confirms the endpoint is alive but correctly rejects non-POST requests).
4. Check interval: 300 seconds.
5. Label: Drone Webhook Endpoint

A 405 response to a GET confirms the webhook endpoint is routing correctly. A 502 or timeout means the receiver is unreachable and new commits will never trigger pipelines.

Step 6: SSL Certificate Alerts

Drone communicates with GitHub, Gitea, or Forgejo via webhooks over HTTPS. An expired certificate breaks webhook delivery entirely — and the failure is silent on the git provider side: pushes succeed but no pipelines run:

1. Add Monitor → SSL Certificate.
2. Domain: drone.yourdomain.com
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days.
5. Click Save.

A 30-day threshold gives you time to renew before developers notice that git push no longer triggers builds.

Step 7: Runner Agent Heartbeat

Drone separates the server (pipeline scheduling) from runners (pipeline execution). A runner that disconnects means pipelines queue indefinitely without executing. Monitor runner health with a cron-based heartbeat:

# /etc/cron.d/drone-runner-heartbeat — runs every 10 minutes
*/10 * * * * root docker inspect --format='{{.State.Status}}' drone-runner | grep -q running && \
  curl -s https://vigilmon.online/api/heartbeat/YOUR-RUNNER-HEARTBEAT-ID

In Vigilmon:

1. Add Monitor → Heartbeat.
2. Expected interval: 10 minutes.
3. Grace period: 20 minutes.
4. Label: Drone Runner Agent

If the runner container exits or enters a restart loop, the heartbeat stops within the grace period and Vigilmon alerts you.

Step 8: Pipeline Execution Heartbeat

Add a heartbeat ping at the end of a critical pipeline to verify end-to-end CI health — that Drone is not just running but actually completing successful builds:

# .drone.yml
steps:
  - name: build
    image: node:20
    commands:
      - npm ci
      - npm test

  - name: vigilmon-heartbeat
    image: curlimages/curl
    commands:
      - curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-BUILD-HEARTBEAT-ID
    when:
      status:
        - success

In Vigilmon:

1. Add Monitor → Heartbeat.
2. Expected interval: Match your commit frequency (e.g., 60 minutes).
3. Label: Drone Build Completion

The when: status: success condition ensures the heartbeat only fires on successful pipeline completion. If builds start consistently failing, the heartbeat stops and Vigilmon alerts you — even if you're not watching the dashboard.

Common Drone CI Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Drone server process crash | /healthz check fires within 60 s | | Database connection failure | Health endpoint returns non-200 | | Build API layer failure | Build API heartbeat stops | | Runner agent disconnects | Runner heartbeat stops within grace period | | Pipeline queue backlogged | Queue heartbeat stops | | Webhook endpoint unreachable | Webhook HTTP monitor fires | | SSL certificate expires | SSL monitor alerts at 30 days; webhooks break | | Container exit behind reverse proxy | TCP port check and health monitor fire | | Builds consistently failing | Build completion heartbeat stops | | DNS misconfiguration | All HTTP and SSL monitors fire |

Self-hosting Drone gives you fast, private CI/CD with no per-seat costs. Vigilmon ensures that CI pipeline is always running — watching the web UI, health endpoint, build API, queue depth, webhooks, runners, and SSL certificate simultaneously so you know the moment something breaks, before your team notices pipelines are stuck.

Start monitoring Drone CI in under 5 minutes — register free at vigilmon.online.