tutorial

Monitoring DDNS Updater with Vigilmon

DDNS Updater keeps your DNS records pointing at the right IP — but a failed update leaves your domain stale and unreachable. Here's how to monitor every update job, external IP detection, and DNS provider API health with Vigilmon.

DDNS Updater silently keeps your domain pointing at your home or office IP even when the ISP changes it. When it works, you never think about it. When it fails — a stale DNS record, a dead provider API call, a crashed Go process — your domain stops resolving and you find out from someone else. Vigilmon monitors the web UI, each DNS update job, external IP detection, and provider API connectivity so a silent failure becomes an immediate alert.

What You'll Set Up

  • Web server and UI availability monitor
  • Heartbeat monitors for each configured domain update job
  • External IP detection service health check
  • DNS provider API connectivity monitoring
  • SSL/TLS certificate expiry alerts

Prerequisites

  • DDNS Updater running (Go, default port 8000)
  • At least one domain record configured in config.json
  • A free Vigilmon account

Step 1: Monitor the Web UI

DDNS Updater ships a built-in web UI showing current IP, last update time, and per-record status. This is your first health signal — if the UI is down, the Go process has crashed.

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

If you run DDNS Updater behind a reverse proxy with HTTPS, use the HTTPS URL:

https://ddns.yourdomain.com/

A 200 from the root confirms the Go HTTP server is alive and the UI is serving. Process crashes, port conflicts, and OOM kills will all surface here.

Step 2: Monitor the Health Endpoint

DDNS Updater exposes a /healthcheck endpoint (added in recent versions) that returns HTTP 200 when all configured providers are reachable and updates are running on schedule.

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter: http://your-server-ip:8000/healthcheck
  3. Set Check interval to 2 minutes.
  4. Set Expected HTTP status to 200.
  5. Click Save.

If your version doesn't expose /healthcheck, use the root UI monitor from Step 1 as your primary liveness check.

Step 3: Heartbeat for Each DNS Update Job

Each configured domain record in DDNS Updater runs on its own update schedule (typically every 5–10 minutes). A failed update leaves DNS stale — you need to know per-record, not just per-process.

DDNS Updater doesn't call external webhooks natively, but you can wire heartbeats using a companion script that reads DDNS Updater's log file or status API.

Create /opt/ddns-updater/heartbeat.sh:

#!/bin/bash
# Check if the last update for each domain was successful
DDNS_LOG="/var/log/ddns-updater/output.log"
HEARTBEAT_CLOUDFLARE="https://vigilmon.online/heartbeat/YOUR_CF_TOKEN"
HEARTBEAT_GODADDY="https://vigilmon.online/heartbeat/YOUR_GD_TOKEN"

# Check last successful update within the last 15 minutes
if grep -q "cloudflare.*success\|updated successfully" "$DDNS_LOG" 2>/dev/null; then
  LAST_SUCCESS=$(grep -E "cloudflare.*success" "$DDNS_LOG" | tail -1)
  curl -s "$HEARTBEAT_CLOUDFLARE" > /dev/null
fi

if grep -q "godaddy.*success\|updated successfully" "$DDNS_LOG" 2>/dev/null; then
  curl -s "$HEARTBEAT_GODADDY" > /dev/null
fi

Add to cron to run every 10 minutes:

*/10 * * * * /opt/ddns-updater/heartbeat.sh

In Vigilmon, create one Cron Heartbeat per domain record:

  1. Click Add Monitor → Cron Heartbeat.
  2. Name it after the domain (e.g., DDNS: home.example.com via Cloudflare).
  3. Set Expected interval to 15 minutes (update interval + buffer).
  4. Copy the heartbeat URL into the script.
  5. Click Save.

A missed heartbeat means DDNS Updater stopped successfully updating that specific record — either a provider API failure or a credential issue.

Step 4: Monitor External IP Detection

DDNS Updater periodically queries an external service to learn the current public IP (ipinfo.io, api.ipify.org, etc.). If that external service is unreachable, DDNS Updater can't detect an IP change and will skip updates.

Monitor the IP detection endpoints DDNS Updater uses:

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter: https://api.ipify.org/
  3. Set Check interval to 5 minutes.
  4. Set Expected HTTP status to 200.
  5. Enable Expected content and set it to a regex matching an IP address: \d+\.\d+\.\d+\.\d+
  6. Click Save.

Add a second monitor for your configured fallback IP service (check your config.json for which services DDNS Updater is using):

https://ipinfo.io/ip
https://checkip.amazonaws.com

External IP detection failures are often temporary — set Consecutive failures before alert to 3.

Step 5: Monitor DNS Provider API Connectivity

DDNS Updater makes API calls to your DNS provider (Cloudflare, GoDaddy, Namecheap, etc.) to push IP updates. If the provider API is unreachable or rate-limiting, updates silently fail.

Add monitors for each DNS provider API you rely on:

Cloudflare API:

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter: https://api.cloudflare.com/client/v4/
  3. Set Expected HTTP status to 200.
  4. Set Check interval to 5 minutes.

GoDaddy API:

https://api.godaddy.com/

Namecheap API:

https://dynamicdns.park-your-domain.com/

DuckDNS:

https://www.duckdns.org/

These monitors don't authenticate — they just verify the provider's API surface is reachable. A 200 from api.cloudflare.com/client/v4/ doesn't mean your credentials are valid, but an error means DDNS Updater's API call will fail before it even tries.

Step 6: Monitor IP Change Events

When your public IP changes, DDNS Updater should detect and push the update within one check interval. Delayed propagation leaves DNS pointing at the old IP.

Add a cron job that watches for IP changes and pings a dedicated Vigilmon heartbeat when a change is detected and successfully pushed:

#!/bin/bash
LAST_IP_FILE="/tmp/ddns-last-ip"
CURRENT_IP=$(curl -s https://api.ipify.org)
HEARTBEAT_CHANGE="https://vigilmon.online/heartbeat/YOUR_CHANGE_TOKEN"

if [ -f "$LAST_IP_FILE" ]; then
  LAST_IP=$(cat "$LAST_IP_FILE")
  if [ "$CURRENT_IP" != "$LAST_IP" ]; then
    # IP changed — wait for DDNS Updater to push, then heartbeat
    sleep 60
    NEW_DNS=$(dig +short yourdomain.com @8.8.8.8)
    if [ "$NEW_DNS" = "$CURRENT_IP" ]; then
      curl -s "$HEARTBEAT_CHANGE" > /dev/null
    fi
  fi
fi
echo "$CURRENT_IP" > "$LAST_IP_FILE"

In Vigilmon, set this heartbeat to a long interval (24 hours) — it should fire whenever an IP change is pushed successfully. If an IP change happened but the heartbeat didn't arrive within the window, the propagation failed.

Step 7: Monitor Database/File Persistence Health

DDNS Updater stores the last known IP and update timestamps in a local file (data.json by default). If this file becomes unwritable (disk full, permissions changed), DDNS Updater may run but lose update state across restarts.

Add a disk space monitor for the data directory:

#!/bin/bash
HEARTBEAT="https://vigilmon.online/heartbeat/YOUR_DISK_TOKEN"
DATA_FILE="/opt/ddns-updater/data/data.json"

if [ -w "$DATA_FILE" ] && [ -f "$DATA_FILE" ]; then
  DISK_FREE=$(df -P /opt/ddns-updater | awk 'NR==2 {print $5}' | tr -d '%')
  if [ "$DISK_FREE" -lt "90" ]; then
    curl -s "$HEARTBEAT" > /dev/null
  fi
fi

Set the heartbeat interval to 10 minutes. If the data file becomes unwritable or disk usage hits 90%, the ping stops and you're alerted.

Step 8: SSL/TLS Certificate Expiry Monitoring

If DDNS Updater runs behind a reverse proxy with TLS, add certificate monitoring:

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

Step 9: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add email, Slack, or a webhook.
  2. For the web UI monitor: Consecutive failures before alert = 2.
  3. For update job heartbeats: leave at 1 — a missed update heartbeat is always significant.
  4. For external IP and provider API monitors: Consecutive failures before alert = 3.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web UI | http://server:8000/ | Go process crash | | Health endpoint | /healthcheck | Internal health failure | | Update job heartbeat | Per-domain cron heartbeat | Stale DNS record | | IP detection | ipify.org, ipinfo.io | Can't detect IP changes | | Provider API | Cloudflare, GoDaddy, etc. | API unreachable | | IP change propagation | Change-event heartbeat | Delayed DNS update on IP change | | Disk/data persistence | Cron heartbeat on writable check | Corrupted or unwritable state | | SSL certificate | HTTPS proxy URL | Certificate expiry |

DDNS Updater is the quiet workhorse that keeps your domain reachable through dynamic IPs. With Vigilmon watching the process, each update job, IP detection services, and provider APIs, a silent failure becomes a prompt alert — before anyone else notices your domain went stale.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles