tutorial

Monitoring Self-Hosted Chartbrew with Vigilmon

Chartbrew is an open-source data visualization platform you can self-host for full data control — here's how to monitor its API, chart rendering service, database connections, and scheduled report delivery with Vigilmon.

Chartbrew lets you build live dashboards and charts connected directly to your databases and APIs — all hosted on your own infrastructure. But when the Chartbrew API goes down or a scheduled report fails to deliver, stakeholders may not notice until they check their dashboard and find it showing stale data or nothing at all. Vigilmon gives you proactive monitoring across Chartbrew's API, chart rendering pipeline, and scheduled delivery so you catch outages before business users do.

What You'll Set Up

  • HTTP health monitor for the Chartbrew API on port 3210
  • Chart rendering service availability check
  • Database connection monitoring via TCP
  • Cron heartbeat for scheduled report delivery verification
  • SSL certificate and alerting configuration

Prerequisites

  • Chartbrew self-hosted (Docker Compose or direct Node.js installation)
  • Chartbrew accessible on port 3210 (default API port) and 3000 (default frontend port)
  • A free Vigilmon account

Step 1: Monitor the Chartbrew API

The Chartbrew API handles all data connections, chart queries, and user requests. It's the core service that needs to be running for any dashboard functionality.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the URL: http://your-chartbrew-host:3210/
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

The Chartbrew API root path returns a 200 when the server is running. If the Node.js process has crashed or the server is overloaded and unable to accept connections, the monitor returns a connection error or timeout.

For a more meaningful health check, probe the ping endpoint if configured:

http://your-chartbrew-host:3210/ping

This is lighter than a full API call and avoids query execution overhead in your monitoring traffic.

Step 2: Monitor the Chartbrew Frontend

The Chartbrew frontend (React app) is served separately from the API and can fail independently. Stakeholders access dashboards through the frontend, so its availability is the user-visible health signal.

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter: http://your-chartbrew-host:3000
  3. Set Check interval to 2 minutes.
  4. Set Expected HTTP status to 200.
  5. Under Keyword match, enter Chartbrew to confirm the correct application is being served.
  6. Click Save.

A separate frontend monitor helps you distinguish between "the API is down" (data queries fail) and "the frontend is down" (users can't access dashboards at all) — two different problems with different resolution steps.

Step 3: Verify Chart Data Rendering

Chartbrew renders charts by executing queries against connected data sources. A successful API health check doesn't guarantee that chart rendering works — if a data source connection fails, charts show blank or error states without any service-level alert.

Add a monitor that probes the chart data endpoint:

  1. Click Add Monitor → HTTP / HTTPS.

  2. Enter: http://your-chartbrew-host:3210/project/{your-project-id}/charts

    Replace {your-project-id} with an ID from your Chartbrew instance (visible in the dashboard URL).

  3. Add the API authorization header:

    • Under Custom headers, add: Authorization: Bearer YOUR_CHARTBREW_API_KEY

  4. Set Check interval to 5 minutes.

  5. Set Expected HTTP status to 200.

  6. Click Save.

If this monitor fails while the API root is healthy, the specific data source connection for that project is the likely culprit — not the Chartbrew service itself.

Step 4: Monitor Database Connectivity

Chartbrew stores dashboards, chart configurations, and user data in a MySQL or PostgreSQL database. A database outage stops all chart saves and project management operations.

MySQL (default Chartbrew database)

  1. Click Add Monitor → TCP Port.
  2. Host: your-chartbrew-host
  3. Port: 3306
  4. Set Check interval to 2 minutes.
  5. Click Save.

PostgreSQL (if configured)

  1. Click Add Monitor → TCP Port.
  2. Host: your-chartbrew-host
  3. Port: 5432
  4. Set Check interval to 2 minutes.
  5. Click Save.

Pairing database TCP monitors with the API monitor gives you fast root-cause identification: if the API is degraded and the database TCP check is failing, the database is the bottleneck rather than the Node.js application itself.

Step 5: Monitor Scheduled Report Delivery

Chartbrew can send scheduled dashboard reports via email or webhook. If the scheduler process stalls, reports stop going out — but no visible error appears in the UI or logs unless you're actively looking.

Use a Vigilmon cron heartbeat to detect silently stalled scheduled deliveries:

  1. Click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to match your most frequent scheduled report (e.g. 60 minutes for hourly reports).
  3. Copy the heartbeat URL (e.g. https://vigilmon.online/heartbeat/abc123).

Integrate the ping into Chartbrew's scheduler. If you're using Docker Compose, add a sidecar health script on your host:

#!/bin/bash
# /usr/local/bin/chartbrew-scheduler-check.sh

# Check if the Chartbrew API process is handling scheduler tasks
# Probe the scheduler status endpoint if available, else check process liveness
if curl -s --max-time 5 http://localhost:3210/ > /dev/null 2>&1; then
  curl -s --max-time 10 https://vigilmon.online/heartbeat/abc123
fi

Schedule it to run at the same frequency as your most frequent report:

0 * * * * /usr/local/bin/chartbrew-scheduler-check.sh

If Chartbrew restarts mid-schedule and skips a delivery cycle, the heartbeat stops arriving and Vigilmon alerts after the expected interval passes.

Step 6: SSL Certificate and Alerting

SSL monitoring

If you've placed Chartbrew behind a reverse proxy with TLS:

  1. Open the frontend monitor from Step 2.
  2. Update the URL to https://charts.yourdomain.com.
  3. Enable Monitor SSL certificate.
  4. Set Alert when certificate expires in less than 21 days.
  5. Click Save.

Alert channel setup

  1. Go to Alert Channels in Vigilmon.
  2. Add Slack, email, or a webhook for on-call notification.
  3. Assign the alert channel to each Chartbrew monitor.

Reduce false positives during deployments

Node.js restarts take a few seconds. Set Consecutive failures before alert to 2 on the API and frontend monitors to avoid alerting during brief deploys.

Maintenance windows

Open a maintenance window before restarting or upgrading Chartbrew:

curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "monitor_id": "chartbrew-api-monitor-id",
    "duration_minutes": 10
  }'

# Restart Chartbrew
docker compose restart chartbrew-api

# Window expires automatically

Summary

| Monitor | Target | What It Catches | |---|---|---| | API service | :3210/ | Node.js crash, service unavailable | | Frontend | :3000 | Dashboard UI down for users | | Chart data endpoint | :3210/project/.../charts | Data source query failures | | Database TCP | :3306 or :5432 | Database connectivity loss | | Scheduler heartbeat | Cron ping hourly | Scheduled reports silently stalled | | SSL certificate | https://charts.yourdomain.com | Certificate expiry |

Chartbrew's value is delivering fresh data to dashboards and scheduled reports on time — and that delivery chain depends on the API, frontend, database, and scheduler all being healthy simultaneously. With Vigilmon covering each layer independently, you'll know exactly which component broke when stakeholders report stale dashboards, long before they need to report it at all.

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