Monitoring Pairdrop with Vigilmon

Pairdrop is a privacy-first, self-hosted file sharing application that works in any browser — no app install, no accounts, no cloud relay. It runs as a Node.js/Express server and uses WebRTC for peer-to-peer transfers, with a WebSocket signaling server to coordinate peer discovery on your local network. Self-hosting Pairdrop gives your household or office a zero-trust file transfer tool, but it also means you're responsible for keeping the server and its TLS layer healthy. Vigilmon lets you watch the web server, signaling layer, certificate health, and reverse proxy from a single dashboard.

What You'll Set Up

• HTTP uptime monitor for the Pairdrop web server (port 3000)
• WebSocket signaling server TCP health check
• TLS/SSL certificate expiry alert for your Pairdrop domain
• nginx reverse proxy availability monitor
• Cron heartbeat for confirming the Node.js process stays alive

Prerequisites

• Pairdrop running via Node.js or Docker (default port 3000)
• nginx or Caddy reverse proxy for HTTPS (recommended for WSS support)
• A free Vigilmon account

Step 1: Monitor the Pairdrop Web Server

Pairdrop serves its web interface and signaling server from the same Node.js process on port 3000. Start with an HTTP monitor on the root path:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter the URL: https://pairdrop.yourdomain.com/ (or http://your-host:3000/ for internal monitoring).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Pairdrop returns the main HTML page at /. A 200 response confirms the Node.js server is alive and the express router is handling requests.

Step 2: Monitor WebSocket Peer Discovery

Pairdrop uses a WebSocket server (on the same port as the HTTP server) for peer discovery — devices open a WebSocket connection to announce themselves and discover peers on the same network segment. If the WebSocket handler crashes or the process becomes unresponsive, peers stop discovering each other even though the HTTP page loads fine.

Add a TCP port monitor to confirm the server is accepting connections on port 3000:

1. Click Add Monitor → TCP Port.
2. Host: your-host (or pairdrop.yourdomain.com).
3. Port: 3000 (or 443 if you terminate TLS at nginx).
4. Check interval: 1 minute.
5. Click Save.

For WSS (WebSocket over TLS) through nginx, the underlying TCP connection lands on port 443 — the same port as your HTTPS traffic. A TCP check on port 443 covers both the web app and the WebSocket upgrade path simultaneously.

Step 3: Add a Process-Level Heartbeat

The HTTP and TCP monitors confirm the port is open, but they won't catch a Node.js process that is stuck in an event loop deadlock — accepting connections but not processing them. Add a Vigilmon cron heartbeat pinged from inside the process:

Option A: External health endpoint

Add a lightweight /healthz route to your Pairdrop instance (if you run a fork or a wrapper):

app.get('/healthz', (req, res) => {
  res.json({ status: 'ok', uptime: process.uptime() });
});

Then monitor https://pairdrop.yourdomain.com/healthz expecting 200.

Option B: Systemd or Docker watchdog script

If you run Pairdrop under systemd:

#!/bin/bash
# /opt/pairdrop/heartbeat.sh
curl -sf http://localhost:3000/ -o /dev/null && \
  curl -s https://vigilmon.online/heartbeat/YOUR_HEARTBEAT_ID

Create a Vigilmon heartbeat monitor (click Add Monitor → Cron Heartbeat, interval 2 minutes), copy the heartbeat URL, and schedule the script:

*/2 * * * * /opt/pairdrop/heartbeat.sh

Step 4: Monitor TLS Certificate Health

Pairdrop's peer discovery relies on WebSocket Secure (WSS) connections. Browsers will refuse a WSS connection to a domain with an expired or invalid TLS certificate, completely breaking peer discovery even though the server process is running.

Enable SSL monitoring on your existing HTTPS monitor:

1. Open the https://pairdrop.yourdomain.com/ monitor.
2. Enable Monitor SSL certificate.
3. Set Alert when certificate expires in less than 21 days.
4. Click Save.

If you use Let's Encrypt with Certbot, verify your renewal timer is active:

systemctl status certbot.timer
# Should show "active (waiting)"

Manual renewal check:

certbot renew --dry-run

A 21-day alert window gives you three weekly opportunities to renew before the certificate causes user-visible failures.

Step 5: Monitor the nginx Reverse Proxy

If you run nginx in front of Pairdrop (recommended for WSS and HTTPS termination), add a monitor for the nginx server itself. nginx can fail to reload after a certificate renewal or configuration change, leaving Pairdrop unreachable even though the Node.js process is healthy.

1. Click Add Monitor → HTTP / HTTPS.
2. URL: https://pairdrop.yourdomain.com/ (this already covers nginx — the existing Step 1 monitor tests through nginx).
3. For a separate nginx health check, enable the nginx stub_status module and add a dedicated monitor:

# /etc/nginx/conf.d/status.conf
server {
    listen 127.0.0.1:8080;
    location /nginx-status {
        stub_status;
        allow 127.0.0.1;
        deny all;
    }
}

Then use a local heartbeat script that reads nginx status and pings Vigilmon:

#!/bin/bash
curl -sf http://127.0.0.1:8080/nginx-status -o /dev/null && \
  curl -s https://vigilmon.online/heartbeat/NGINX_HEARTBEAT_ID

Step 6: Monitor Connection Timeout Events

Pairdrop's WebSocket signaling server logs connection timeouts and peer disconnects. High timeout rates indicate network interface binding issues or NAT traversal problems on your network. Set up log-based alerting with a heartbeat that only pings Vigilmon when the error rate is below threshold:

#!/bin/bash
# /opt/pairdrop/timeout-check.sh
ERRORS=$(journalctl -u pairdrop --since "5 minutes ago" | grep -c "timeout" || true)
if [ "$ERRORS" -lt 10 ]; then
  curl -s https://vigilmon.online/heartbeat/TIMEOUT_HEARTBEAT_ID
fi

Create a Vigilmon heartbeat monitor with a 10 minute expected interval and schedule this script every 5 minutes. If errors spike, the heartbeat stops pinging and Vigilmon alerts you after 10 minutes of silence.

Step 7: Configure Alert Channels

1. Go to Alert Channels in Vigilmon.
2. Add email or Slack for immediate notification.
3. Set Consecutive failures before alert to 2 — Pairdrop's Node.js process occasionally takes 5–10 seconds to respond under initial WebRTC negotiation load, which can cause a single probe to time out.
4. For home lab setups, use the Vigilmon webhook channel to push alerts to a self-hosted notification system (Ntfy, Gotify, etc.):

# Ntfy example
curl -d "Pairdrop is DOWN" https://ntfy.sh/your-topic

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web server (HTTP) | https://pairdrop.yourdomain.com/ | Node.js process crash | | WebSocket signaling (TCP) | Port 3000 / 443 | Peer discovery failure | | Process heartbeat (Cron) | Heartbeat URL | Deadlocked process | | TLS certificate (SSL) | Pairdrop domain | Certificate expiry, WSS failure | | nginx proxy (Heartbeat) | nginx-status endpoint | Proxy reload failure | | Timeout rate (Heartbeat) | Log-based script | Network binding / NAT issues |

Pairdrop turns your local network into a zero-setup file transfer hub — but only when the server is running and the TLS layer is intact. With Vigilmon watching the Node.js process, the WebSocket signaling server, and your nginx proxy, you'll know immediately if peer discovery breaks down or certificates lapse before anyone tries to send a file.