Monitoring Shynet Self-Hosted Privacy Analytics with Vigilmon

Shynet is a privacy-focused, self-hosted web analytics platform built on Django. It uses no cookies or fingerprinting, stores data in PostgreSQL, and processes events through Django's built-in queue — making it a clean, auditable alternative to Google Analytics. Running it yourself means the data never leaves your server — but also that uptime is your responsibility. Vigilmon gives you HTTP uptime checks, database-backed API health monitoring, SSL certificate alerts, and worker heartbeats to ensure Shynet is always recording your traffic.

What You'll Set Up

• HTTP uptime monitor for the Shynet dashboard
• Ingestion endpoint health check confirming events are being accepted
• SSL certificate expiry alert
• Heartbeat monitoring for background Celery or Huey workers
• Alert channels for immediate notification

Prerequisites

• Shynet deployed (Docker Compose recommended, version 0.13+)
• PostgreSQL running and accessible to Shynet
• A free Vigilmon account
• Your Shynet domain and Docker Compose file

Step 1: Monitor the Shynet Dashboard

Shynet serves a Django admin-style dashboard at the root URL. An HTTP uptime check confirms the Django application server (Gunicorn) is running:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your Shynet URL: https://shynet.yourdomain.com.
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Shynet redirects unauthenticated users to /accounts/login/, which returns 200. The monitor will pass for an unauthenticated probe, which is the behavior you want — you're verifying the server is alive, not testing authentication.

Step 2: Monitor the Shynet Ingestion Endpoint

Shynet records page views through a tracking pixel and a JavaScript snippet, both of which hit /ingress/<service_uuid>/pixel/. You can probe this endpoint with Vigilmon to verify the ingestion pipeline is alive:

1. Click Add Monitor → HTTP / HTTPS.
2. Set the URL to https://shynet.yourdomain.com/ingress/FAKE-UUID/pixel/. Replace FAKE-UUID with a syntactically valid but non-existent UUID, e.g. 00000000-0000-0000-0000-000000000000.
3. Set Expected HTTP status to 404 — Shynet returns 404 for an unknown service UUID, confirming the ingress route is active and routing correctly.
4. Click Save.

This check is lightweight and confirms that Shynet's ingress route is live without creating fake analytics data in your database.

To use a real service UUID (from one of your configured Shynet services), the pixel returns 200 with a 1x1 GIF body — use that if you prefer a 200 status check.

Step 3: Add a Django Health Check Endpoint

Shynet does not ship a /health endpoint by default. If you control the Shynet source or deployment configuration, add one using the django-health-check package:

pip install django-health-check

In settings.py:

INSTALLED_APPS += [
    'health_check',
    'health_check.db',
    'health_check.cache',
]

In urls.py:

from health_check.views import MainView
urlpatterns += [path('health/', MainView.as_view())]

Then point your Vigilmon monitor at https://shynet.yourdomain.com/health/. A 200 response confirms Django, the database connection, and the cache layer are all healthy.

If you run Shynet from the official Docker image without customization, stick with the ingestion endpoint check from Step 2.

Step 4: SSL Certificate Alerts

Shynet is typically deployed behind an nginx or Caddy reverse proxy with Let's Encrypt. Add a certificate expiry alert to catch renewal failures before they break your tracking scripts:

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

Tracking scripts are loaded by browsers with strict TLS requirements. A certificate failure means your script is silently blocked — page views stop being recorded without any visible error on the site.

Step 5: Heartbeat Monitoring for Background Workers

Shynet processes ingested events asynchronously. If you run a queue-based worker (Celery, Huey, or Django-Q) for tasks like generating reports or processing event batches, use a Vigilmon heartbeat to confirm the worker is alive:

1. In Vigilmon, click Add Monitor → Cron Heartbeat.

2. Set the expected ping interval to your task frequency (e.g. 60 minutes for hourly aggregation).

3. Copy the heartbeat URL, e.g. https://vigilmon.online/heartbeat/abc123.

4. Add the ping to your worker task or cron wrapper:

   # In your periodic task (Celery or Huey)
   import requests
   
   def aggregate_stats():
       # ... aggregation logic ...
       requests.get('https://vigilmon.online/heartbeat/abc123', timeout=5)
   

   Or for a cron-based approach using Docker Compose:

   # /etc/cron.hourly/shynet-aggregate
   docker exec shynet python manage.py aggregate
   curl -s https://vigilmon.online/heartbeat/abc123
   

If the worker container exits or hangs, no ping reaches Vigilmon, and you're alerted after the expected interval passes.

Step 6: Monitor PostgreSQL Connectivity

Shynet requires PostgreSQL. A database failure will bring down the entire application. Use Vigilmon's TCP monitor to check that PostgreSQL is reachable:

1. Click Add Monitor → TCP.
2. Set Host to your PostgreSQL host (e.g. db.yourdomain.com or the internal Docker network hostname if externally exposed).
3. Set Port to 5432.
4. Set Check interval to 1 minute.
5. Click Save.

If PostgreSQL is on the same Docker network and not externally exposed, monitor Shynet's HTTP health endpoint (Step 3) instead — a Django database connection failure will surface as a 500 on the health check route.

Step 7: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. Set Consecutive failures before alert to 2 on the dashboard HTTP monitor to absorb container restart delays.
3. Set Consecutive failures before alert to 1 on the ingestion endpoint — dropped page views should alert immediately.

Automate maintenance windows around Shynet Docker image updates:

# Open a maintenance window
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_VIGILMON_API_KEY" \
  -d '{"monitor_id": "YOUR_MONITOR_ID", "duration_minutes": 10}'

# Pull and restart
docker compose pull shynet && docker compose up -d shynet

# Run Django migrations after upgrade
docker compose exec shynet python manage.py migrate

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP uptime | https://shynet.yourdomain.com | Gunicorn crash, Django error | | Ingestion endpoint | /ingress/.../pixel/ | Ingress route failure, DB disconnect | | Health check | /health/ (if configured) | Database or cache failure | | SSL certificate | Shynet domain | TLS renewal failure | | TCP port | PostgreSQL :5432 | Database unreachable | | Cron heartbeat | Heartbeat URL | Worker crash, missed aggregation |

Shynet gives your users a promise: no cookies, no tracking, just first-party data you control. Vigilmon makes sure you can keep that promise by keeping Shynet running and recording — 24 hours a day.