tutorial

Monitoring LinearB with Vigilmon

LinearB is your engineering intelligence platform — but if its analytics dashboard or data ingestion pipeline goes dark, your DORA metrics go with it. Here's how to monitor LinearB's web dashboard, data pipeline, and all its integrations with Vigilmon.

LinearB gives engineering managers real-time visibility into DORA metrics, PR cycle time, and team velocity — but that visibility depends entirely on LinearB itself staying healthy. If the analytics dashboard goes down, engineering leaders lose their metrics view. If the data ingestion pipeline stalls, DORA metrics silently become stale. Vigilmon keeps a continuous eye on every layer of your self-hosted LinearB deployment: the web dashboard, data pipelines, PostgreSQL, Redis, and all the external integrations that feed it.

What You'll Set Up

  • HTTP uptime monitor for the LinearB analytics dashboard (port 3000)
  • SSL certificate expiry alert for the dashboard domain
  • TCP monitors for PostgreSQL and Redis connectivity
  • Cron heartbeat for DORA metric computation jobs
  • Endpoint checks for GitHub/GitLab and Jira/Linear API connectivity health
  • Alerting with Slack or email

Prerequisites

  • Self-hosted LinearB running on Node.js + PostgreSQL + Redis
  • LinearB web dashboard accessible on port 3000
  • A free Vigilmon account

Step 1: Monitor the LinearB Analytics Dashboard

The LinearB web dashboard runs on port 3000 and is the primary interface for engineering managers to view DORA metrics, PR cycle time, deployment frequency trends, and team velocity. If this service is unavailable, your entire metrics workflow is blocked.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter your LinearB dashboard URL: https://linearb.yourdomain.com (or http://your-server:3000 if not behind a reverse proxy).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

If LinearB exposes a health endpoint (check your deployment docs for /health or /api/health), use it for a deeper signal:

https://linearb.yourdomain.com/api/health

A health endpoint that reports database and Redis connectivity gives you early warning of dependency failures before they affect the UI.

Step 2: SSL Certificate Expiry Alert

LinearB dashboards accessed over HTTPS need a valid certificate — especially when the URL is shared with engineering leadership and accessed from corporate devices with strict TLS policies.

  1. Open the HTTP monitor you 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.

If you're using Let's Encrypt with auto-renewal (via certbot or your reverse proxy), a 21-day window gives you enough runway to investigate and manually renew before expiry causes dashboard outages.

Step 3: Monitor PostgreSQL Connectivity

LinearB stores all git history, PR data, deployment events, and issue tracker records in PostgreSQL. A database outage stops data ingestion and prevents metric computation.

Add a TCP monitor for your PostgreSQL port:

  1. Click Add Monitor → TCP Port.
  2. Enter your database host and port: your-server:5432.
  3. Set Check interval to 1 minute.
  4. Click Save.

To go deeper, expose a lightweight database health endpoint from your LinearB instance or a sidecar probe:

# Simple Postgres reachability probe — run as a cron or service
pg_isready -h localhost -p 5432 -U linearb_user

Add disk space monitoring separately if your PostgreSQL host stores long time-series metric history — these tables grow large as you accumulate months of deployment and PR data.

Step 4: Monitor Redis Connectivity

LinearB uses Redis as a job queue and cache layer. Redis availability is critical for the data ingestion pipeline — webhook events from GitHub/GitLab land in Redis queues before being processed into the database.

Add a TCP monitor for Redis:

  1. Click Add Monitor → TCP Port.
  2. Enter your Redis host and port: your-server:6379.
  3. Set Check interval to 1 minute.
  4. Click Save.

If you run Redis with authentication (recommended for production), ensure your LinearB service has the correct REDIS_PASSWORD environment variable set, and check LinearB logs if Redis connectivity issues appear.

Step 5: Heartbeat for DORA Metric Computation

LinearB computes DORA metrics — deployment frequency, lead time for changes, change failure rate, and time to restore service — by running scheduled computation jobs over the ingested data. If these jobs stall or fail silently, your metrics dashboards show stale numbers without any visible error.

Set up a Vigilmon cron heartbeat to confirm computation jobs are completing:

  1. Click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to match your computation job schedule (e.g. 60 minutes for hourly jobs).
  3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/YOUR_ID.
  4. Add a ping to the end of your computation job script:
#!/bin/bash
# Run DORA metric computation
node /opt/linearb/scripts/compute-metrics.js

# Signal success to Vigilmon
curl -s https://vigilmon.online/heartbeat/YOUR_ID

Or from a Node.js job:

const https = require('https');

async function computeMetrics() {
  await runDORAComputation();
  // Ping heartbeat on success
  https.get('https://vigilmon.online/heartbeat/YOUR_ID');
}

If the computation job crashes before the ping is sent, Vigilmon alerts after the expected interval — giving you early warning of stale DORA data before your engineering managers notice.

Step 6: Monitor GitHub/GitLab API Connectivity

LinearB continuously ingests git event data from GitHub or GitLab — PR opens, review comments, merges, and deployment events. If API connectivity is lost or rate limits are hit, historical data stops flowing and DORA metrics become incomplete.

Add an HTTP monitor to probe the API status:

  1. Click Add Monitor → HTTP / HTTPS.
  2. For GitHub: use https://api.github.com or https://api.github.com/meta.
  3. For GitLab self-hosted: use https://gitlab.yourdomain.com/-/health.
  4. Set Check interval to 5 minutes.
  5. Click Save.

Monitor your API rate limit headroom by adding a lightweight probe that checks the X-RateLimit-Remaining response header. When LinearB is backfilling historical data from a large repository, API calls spike — you want to know before you hit zero.

Step 7: Monitor Jira/Linear API Connectivity

Sprint and ticket data from Jira or Linear feeds into LinearB's engineering intelligence — issue cycle time, sprint completion rates, and developer productivity metrics all depend on this integration. Authentication failures or API outages silently degrade this data stream.

Add an HTTP monitor for your issue tracker:

  1. Click Add Monitor → HTTP / HTTPS.
  2. For Jira Cloud: https://your-org.atlassian.net/rest/api/3/serverInfo.
  3. For Linear: https://api.linear.app/graphql (POST with a simple introspection query, or use a dedicated status endpoint).
  4. Set Check interval to 5 minutes.
  5. Click Save.

If you manage LinearB's integration tokens, alert your team when tokens are within 30 days of rotation so API authentication doesn't break due to expired credentials.

Step 8: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add your preferred channel — Slack, email, or webhook.
  2. For the dashboard monitor, set Consecutive failures before alert to 2 — a single probe failure may be a transient network blip.
  3. For the PostgreSQL and Redis TCP monitors, alert on 1 failure — database and cache outages are rarely transient.
  4. Route critical alerts (database, Redis) to an on-call channel; route dashboard and API alerts to your engineering team channel.

Example Slack alert routing:

| Monitor | Channel | Threshold | |---|---|---| | Dashboard (port 3000) | #eng-alerts | 2 failures | | PostgreSQL TCP | #on-call | 1 failure | | Redis TCP | #on-call | 1 failure | | DORA computation heartbeat | #eng-alerts | 1 missed beat | | GitHub API | #eng-alerts | 2 failures |

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP dashboard | https://linearb.yourdomain.com | Dashboard outage, app crash | | SSL certificate | Dashboard domain | Certificate expiry | | TCP | PostgreSQL port 5432 | Database outage | | TCP | Redis port 6379 | Queue and cache outage | | Cron heartbeat | Heartbeat URL | Stale DORA metrics, failed computation | | HTTP | GitHub/GitLab API | Integration data gap | | HTTP | Jira/Linear API | Sprint data freshness |

LinearB makes engineering teams measurable — but measurement only works when LinearB itself is running. With Vigilmon watching the dashboard, data pipelines, and every external integration, you'll know the moment something breaks before your DORA metrics become a lie.

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