Monitoring Radicle with Vigilmon

Radicle replaces centralized Git hosting with a peer-to-peer network of seed nodes — no GitHub, no central server, just Git objects replicated across nodes you choose. But decentralized doesn't mean self-monitoring: if your radicle-node daemon crashes or your seed gets network-isolated, repositories stop replicating and your CI/CD integrations go dark. Vigilmon gives you continuous monitoring of your Radicle node's P2P connectivity, HTTP API, storage, and replication health.

What You'll Set Up

Radicle node daemon health check (TCP port 8776 P2P liveness)
radicle-httpd HTTP API health check on port 8080
P2P peer connectivity count alerts
Repository replication health per RID
Seed node disk usage monitoring
Identity key integrity check via heartbeat

Prerequisites

radicle-node (rad) daemon running with TCP port 8776 open
radicle-httpd running on port 8080 (optional but recommended for web UI and CI integrations)
A free Vigilmon account

Step 1: Monitor the Radicle Node Daemon

The radicle-node daemon maintains the P2P gossip network that replicates repositories. If it crashes, replication stops and your node disappears from the Radicle network.

Monitor the P2P gossip port directly:

Log in to vigilmon.online and click Add Monitor.
Set Type to TCP Port.
Enter Host: your-seed-hostname and Port: 8776.
Set Check interval to 1 minute.
Click Save.

A TCP-level check confirms the daemon is alive and accepting P2P connections. If radicle-node crashes, port 8776 goes silent within one check cycle.

Step 2: Monitor the radicle-httpd API

radicle-httpd exposes a JSON API on port 8080 used by the web UI, CI/CD webhooks, and browse-by-browser flows. An unavailable httpd breaks all web-based access and any CI pipelines that poll for patch status.

Add Monitor → Type: HTTP / HTTPS.
URL: http://your-seed-hostname:8080/api/v1/node
Check interval: 1 minute.
Expected status: 200.
Keyword: "id": — confirms the node responded with a valid node info payload (not just a default 200).
Save.

If you front radicle-httpd with an nginx reverse proxy on port 443, monitor the HTTPS endpoint instead and enable SSL certificate expiry alerts:

Add Monitor → Type: SSL Certificate.
Host: your-seed-hostname, Port: 443.
Alert at: 30 days before expiry.

Step 3: Monitor P2P Peer Connectivity

A Radicle node with zero connected peers is effectively isolated — no replication in or out. Query the node's peer count and alert when it drops to zero.

Create a health-check script /usr/local/bin/radicle-peer-check.sh:

#!/bin/bash
PEER_COUNT=$(rad node peers 2>/dev/null | tail -n +2 | wc -l)
if [ "$PEER_COUNT" -gt 0 ]; then
  curl -s "https://vigilmon.online/heartbeat/$PEERS_TOKEN"
fi

Add to cron every 5 minutes:

*/5 * * * * /usr/local/bin/radicle-peer-check.sh

Set up a Vigilmon Heartbeat monitor with a 10-minute expected interval. When peer count drops to zero, the heartbeat stops — Vigilmon alerts you.

Alternatively, query the radicle-httpd API for peer count:

PEER_COUNT=$(curl -s http://localhost:8080/api/v1/node/peers | python3 -c "import sys,json; print(len(json.load(sys.stdin)))")

Step 4: Monitor Repository Replication Health

Each Radicle repository has an RID (Repository ID). Repositories should be replicated across the seed nodes your node is configured to follow. A replication failure means your repository disappears if your local node goes down.

Create a replication check for a specific repository:

#!/bin/bash
RID="${1:-rad:your-repo-rid-here}"
# Check that the repo exists and has remote refs from at least one peer
REMOTES=$(rad inspect "$RID" --refs 2>/dev/null | grep "refs/remotes" | wc -l)
if [ "$REMOTES" -gt 0 ]; then
  curl -s "https://vigilmon.online/heartbeat/$REPLICATION_TOKEN"
fi

Run via cron every 15 minutes per critical repository. Set the Vigilmon heartbeat interval to 30 minutes. If replication drops — no remote refs are present — the heartbeat goes silent and you're alerted.

For multiple repositories, loop over your tracked RIDs:

RIDS=("rad:abc123" "rad:def456")
ALL_OK=true
for RID in "${RIDS[@]}"; do
  COUNT=$(rad inspect "$RID" --refs 2>/dev/null | grep "refs/remotes" | wc -l)
  [ "$COUNT" -eq 0 ] && ALL_OK=false
done
$ALL_OK && curl -s "https://vigilmon.online/heartbeat/$REPLICATION_TOKEN"

Step 5: Monitor Seed Storage Usage

Radicle seed nodes accumulate Git object data from all replicated repositories. A full disk causes replication writes to fail silently.

Create a storage check script /usr/local/bin/radicle-disk-check.sh:

#!/bin/bash
RADICLE_DIR="${HOME}/.radicle"
USAGE=$(df "$RADICLE_DIR" | awk 'NR==2 {print $5}' | tr -d '%')
if [ "$USAGE" -lt 80 ]; then
  curl -s "https://vigilmon.online/heartbeat/$DISK_TOKEN"
fi

Add to cron every 10 minutes.
In Vigilmon: Add Monitor → Type: Heartbeat, expected interval 20 minutes.

Alert at >80% disk usage on the Radicle data directory. Above this threshold, new repository fetches may fail to write.

Step 6: Monitor Identity Key Integrity

Radicle uses Ed25519 keys stored in ~/.radicle/keys/. A missing or corrupted key file prevents all repository operations — signing commits, pushing patches, and authenticating to the P2P network.

Check key file integrity via a heartbeat:

#!/bin/bash
KEY_FILE="${HOME}/.radicle/keys/radicle"
# Key file must exist and be readable, not world-readable
if [ -f "$KEY_FILE" ] && [ "$(stat -c %a "$KEY_FILE")" = "600" ]; then
  curl -s "https://vigilmon.online/heartbeat/$KEY_TOKEN"
fi

Run via daily cron. Set Vigilmon heartbeat expected interval to 25 hours. Permissions other than 600 may indicate tampering or accidental exposure.

Step 7: Monitor Repository Fetch Latency

Slow P2P fetches indicate network congestion or degraded peer connectivity. Add a synthetic fetch latency check:

#!/bin/bash
# Time a lightweight metadata fetch for a known RID
START=$(date +%s%3N)
rad fetch rad:your-well-known-rid 2>/dev/null
END=$(date +%s%3N)
LATENCY=$((END - START))
# Alert if latency exceeds 30 seconds (30000ms)
if [ "$LATENCY" -lt 30000 ]; then
  curl -s "https://vigilmon.online/heartbeat/$LATENCY_TOKEN"
fi

Run every 15 minutes via cron. Set the heartbeat interval to 30 minutes. Missing heartbeats indicate P2P network congestion or routing issues isolating your seed.

Step 8: Configure Alerting

In Vigilmon, navigate to Alert Channels and add your notification destinations:

Email — for reliable async alerting
Slack or Discord webhook — for real-time team visibility
PagerDuty — for seed operators who need pager coverage on replication outages

Recommended alert policy per monitor:

| Monitor | Condition | Priority | |---|---|---| | radicle-node TCP 8776 | Port unreachable | Page immediately | | radicle-httpd HTTP API | Non-200 or missing keyword | Alert within 5 min | | Peer connectivity | Heartbeat missed | Alert within 10 min | | Repository replication | Heartbeat missed | Alert within 30 min | | Disk usage | Heartbeat missed | Alert within 20 min | | Identity key | Heartbeat missed | Alert within 24 hr |

Conclusion

Radicle's decentralized model means your repositories are only as available as your node. With Vigilmon watching the P2P gossip port, the HTTP API, peer connectivity, replication health, and disk capacity, you get the same observability you'd expect from a centralized git host — without centralization. Add heartbeat monitors for key integrity and fetch latency, wire up your alert channels, and your Radicle seed node is fully observable.