Monitoring Traggo with Vigilmon

Traggo is a self-hosted time tracking tool built around a flexible tag system — instead of rigid project hierarchies, you tag time entries however makes sense for your workflow. It's lightweight, runs on a single binary, and stores everything in SQLite. But "lightweight and self-hosted" also means "entirely your responsibility to keep running." If Traggo goes down, time entries don't get logged and historical data becomes incomplete. Vigilmon monitors Traggo's web interface, GraphQL API, database health, and SSL certificate so your time tracking data stays continuous.

What You'll Set Up

• HTTP uptime monitor for the Traggo web UI at port 3030
• GraphQL API health check via the /graphql endpoint
• Database connectivity monitoring (SQLite via heartbeat)
• SSL certificate expiry alerts for proxied deployments
• Vigilmon heartbeat to confirm the Traggo service keeps running

Prerequisites

• Traggo running via Docker or the standalone binary (default port: 3030)
• SQLite database file on the host or in a Docker volume
• Optional: nginx or Caddy reverse proxy for HTTPS
• A free Vigilmon account

Step 1: Monitor the Traggo Web UI

Traggo serves its React frontend and API from the same port (3030 by default). An HTTP monitor confirms the entire service is up:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your Traggo URL: http://your-server-ip:3030 (or https://traggo.yourdomain.com if proxied).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Click Save.

Traggo's root route returns the web app shell — a 200 response confirms the Go binary is running and serving both the frontend and GraphQL backend.

Step 2: Health Check the GraphQL API

Traggo's entire backend is a GraphQL API served at /graphql. A simple introspection query is the most reliable way to verify the API layer is functional:

curl -s -X POST https://traggo.yourdomain.com/graphql \
  -H 'Content-Type: application/json' \
  -d '{"query": "{ __typename }"}' | grep -q '"__typename"'

Add this as a Vigilmon heartbeat probe:

#!/bin/bash
# /usr/local/bin/check-traggo-graphql.sh
RESPONSE=$(curl -s -X POST https://traggo.yourdomain.com/graphql \
  -H 'Content-Type: application/json' \
  -d '{"query": "{ __typename }"}')

if echo "$RESPONSE" | grep -q '"__typename"'; then
  curl -s https://vigilmon.online/heartbeat/YOUR_GRAPHQL_HEARTBEAT_ID
fi

In Vigilmon:

1. Click Add Monitor → Cron Heartbeat.
2. Set the expected interval to 5 minutes.
3. Copy the heartbeat URL into the script above.
4. Schedule the script: */5 * * * * /usr/local/bin/check-traggo-graphql.sh

If the GraphQL server panics or the database becomes unavailable to it, the introspection query fails and the heartbeat stops — alerting you within 5 minutes.

Step 3: SQLite Database Health

Traggo uses SQLite, which means the database is a file on disk rather than a network service. There's no TCP port to probe, but you can verify database health by checking that the file exists and is accessible, and by querying it directly:

#!/bin/bash
# /usr/local/bin/check-traggo-db.sh
DB_PATH="/var/lib/traggo/traggo.db"

# Check file exists and is readable
if [ ! -r "$DB_PATH" ]; then
  exit 1
fi

# Run a lightweight SQLite query
if sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM tags LIMIT 1;" > /dev/null 2>&1; then
  curl -s https://vigilmon.online/heartbeat/YOUR_DB_HEARTBEAT_ID
fi

For Docker deployments, exec into the container:

#!/bin/bash
if docker exec traggo sqlite3 /data/traggo.db "SELECT 1;" > /dev/null 2>&1; then
  curl -s https://vigilmon.online/heartbeat/YOUR_DB_HEARTBEAT_ID
fi

Create a Cron Heartbeat in Vigilmon with a 10-minute expected interval and schedule the script every 5 minutes.

SQLite and disk space: Unlike network databases, SQLite fails silently when the disk is full — queries start returning errors but the process keeps running. Add a disk space alert on the Traggo host alongside the database heartbeat.

Step 4: Service Continuity Heartbeat

Because Traggo is a single Go binary (or a single Docker container), a simple process-alive heartbeat is your most important monitor. Add a cron job that pings Vigilmon as long as the service is responding:

#!/bin/bash
# /usr/local/bin/traggo-heartbeat.sh
if curl -sf --max-time 10 http://localhost:3030 > /dev/null; then
  curl -s https://vigilmon.online/heartbeat/YOUR_SERVICE_HEARTBEAT_ID
fi

Schedule every minute:

* * * * * /usr/local/bin/traggo-heartbeat.sh

In Vigilmon, set the heartbeat expected interval to 2 minutes — this ensures you're alerted within 2 minutes of the service going down, even if the HTTP monitor hasn't fired yet.

Step 5: SSL Certificate Alerts

If you proxy Traggo through nginx or Caddy for HTTPS:

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

A minimal Caddy config for Traggo:

traggo.yourdomain.com {
    reverse_proxy localhost:3030
}

Caddy handles Let's Encrypt automatically. For nginx:

server {
    listen 443 ssl;
    server_name traggo.yourdomain.com;

    ssl_certificate     /etc/letsencrypt/live/traggo.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/traggo.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3030;
        proxy_set_header Host $host;
    }
}

Step 6: Configure Alert Channels

1. Go to Alert Channels in Vigilmon and add Slack, email, or a webhook.
2. Set the HTTP monitor to alert after 2 consecutive failures — Go binaries restart almost instantly if using Docker restart policies.
3. Set heartbeat monitors (GraphQL, database, service) to alert after 1 missed ping — missed heartbeats are always actionable.
4. Add a Maintenance window when upgrading Traggo to avoid alerts during planned restarts.

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP uptime | http(s)://traggo.yourdomain.com | Go binary crash, container down | | GraphQL heartbeat | /graphql introspection probe | API layer failure, DB unreachable | | SQLite heartbeat | DB file query probe | Corrupt database, disk full | | Service heartbeat | Localhost HTTP probe | Process exit, port closed | | SSL certificate | Your Traggo domain | Certificate expiry |

Time tracking data only has value if it's complete — gaps from downtime are invisible until you try to reconcile billable hours at the end of the month. With Vigilmon watching Traggo's web interface, GraphQL API, SQLite database, and SSL certificate, you'll catch outages in minutes rather than discovering them when the data is already missing.