Monitoring Flame Dashboard with Vigilmon

Flame is a clean, self-hosted startpage and application dashboard that auto-discovers Docker containers, syncs bookmarks, fetches weather data, and provides a unified search experience — all running on port 5005 in your own infrastructure. When Flame goes down, you lose visibility into every service it links to: your homelab becomes a wall of IPs and ports you have to remember from scratch. Vigilmon monitors Flame's web server, REST API, Docker integration, and database so you're alerted the moment anything fails.

What You'll Set Up

• Web server and application availability monitor
• REST API health check
• Docker integration service probe
• Bookmark sync endpoint monitor
• Weather widget API connectivity heartbeat
• SQLite database health check
• SSL certificate monitoring

Prerequisites

• Flame running on port 5005 (standalone Node.js or Docker)
• Docker socket mounted if using container auto-discovery
• A free Vigilmon account

Step 1: Monitor the Flame Web Interface

Flame's primary interface is a React SPA served by its Node.js backend. If the process crashes or the container exits, the dashboard is gone. Add an HTTP monitor:

1. Log in to vigilmon.online and click Add Monitor.
2. Set Type to HTTP / HTTPS.
3. Enter your Flame URL: https://start.yourdomain.com (or http://yourserver:5005).
4. Set Check interval to 1 minute.
5. Set Expected HTTP status to 200.
6. Under Keyword match, enter Flame or startpage — text that appears in the page title or HTML.
7. Click Save.

If Flame is behind a reverse proxy (Nginx, Traefik, Caddy), monitor the public domain — this also validates proxy configuration and SSL termination at the same time.

Step 2: Monitor the Flame REST API

Flame exposes a REST API at /api/ that the frontend uses to fetch apps, bookmarks, and configuration. If the API is broken but the static assets still load, the dashboard appears but shows no content. Add a dedicated API monitor:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://start.yourdomain.com/api/apps (or http://yourserver:5005/api/apps).
3. Set Expected HTTP status to 200.
4. Set Check interval to 2 minutes.
5. Under Keyword match, enter data or [] — the API always returns a JSON array.
6. Click Save.

You can also probe the apps and bookmarks endpoints separately if you want distinct alerts for each feature area:

/api/apps        → application grid
/api/bookmarks   → bookmark list
/api/config      → dashboard configuration

Step 3: Check the Docker Integration Service

One of Flame's most useful features is auto-discovering Docker containers via the Docker socket and displaying them as app tiles. This integration runs on the backend and can break if:

• The Docker socket is unmounted or permission-denied
• The Docker daemon is restarted without restarting Flame
• The DOCKER_HOST environment variable points to a stale socket

Probe the Docker integration via the API endpoint that lists auto-discovered containers:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://start.yourdomain.com/api/apps?type=docker (adjust path for your Flame version).
3. Set Expected HTTP status to 200.
4. Set Check interval to 5 minutes.
5. Click Save.

If Flame doesn't have a Docker-specific API path, add a shell heartbeat that checks the Docker socket directly:

#!/bin/bash
# /usr/local/bin/flame-docker-check.sh

# Check Docker socket is accessible
if docker ps > /dev/null 2>&1; then
  # Check Flame container is running
  if [ "$(docker inspect -f '{{.State.Running}}' flame 2>/dev/null)" = "true" ]; then
    curl -fsS https://vigilmon.online/heartbeat/YOUR_DOCKER_HEARTBEAT_ID
  fi
fi

Run every 5 minutes:

*/5 * * * * /usr/local/bin/flame-docker-check.sh

Step 4: Monitor the Bookmark Sync Endpoint

Flame's bookmark sync allows the browser extension or manual import to update your bookmark list via the API. A broken sync endpoint means new bookmarks are silently lost.

Add a monitor for the bookmark API:

1. Click Add Monitor → HTTP / HTTPS.
2. Enter: https://start.yourdomain.com/api/bookmarks
3. Set Expected HTTP status to 200.
4. Set Check interval to 5 minutes.
5. Click Save.

If the bookmark endpoint requires authentication headers, use a TCP port check as a lightweight alternative:

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

Step 5: Weather Widget API Connectivity

Flame's weather widget fetches data from an external weather API (OpenWeatherMap by default). If the API key is invalid, rate-limited, or the external service is unreachable, the widget shows a loading spinner indefinitely — which can indicate broader network connectivity issues on your server.

Add a heartbeat that checks external API reachability from your server:

#!/bin/bash
# /usr/local/bin/flame-weather-check.sh

# Test external connectivity and DNS resolution
WEATHER_CHECK=$(curl -fsS --max-time 10 \
  "https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_API_KEY" \
  -o /dev/null -w "%{http_code}")

if [ "$WEATHER_CHECK" = "200" ]; then
  curl -fsS https://vigilmon.online/heartbeat/YOUR_WEATHER_HEARTBEAT_ID
fi

Run every 30 minutes (weather API has rate limits):

*/30 * * * * /usr/local/bin/flame-weather-check.sh

This also serves as an external connectivity check — if your server loses outbound internet access, this heartbeat will miss and Vigilmon will alert.

Step 6: SQLite Database Health Check

Flame stores all app configurations, bookmarks, and settings in a SQLite database. A locked or corrupted database causes the API to return 500 errors for every read/write operation.

Add a heartbeat that verifies database integrity:

#!/bin/bash
# /usr/local/bin/flame-db-check.sh

# Default Flame database path (adjust for your installation)
DB_PATH="/opt/flame/data/flame.db"

if [ ! -f "$DB_PATH" ]; then
  echo "Flame database missing at $DB_PATH" >&2
  exit 1
fi

# Check database integrity
RESULT=$(sqlite3 "$DB_PATH" "PRAGMA integrity_check;" 2>/dev/null)
if [ "$RESULT" = "ok" ]; then
  curl -fsS https://vigilmon.online/heartbeat/YOUR_DB_HEARTBEAT_ID
fi

Run every 10 minutes:

*/10 * * * * /usr/local/bin/flame-db-check.sh

For Docker-based Flame installations, the database is typically in a named volume. Find the path:

docker inspect flame | grep -A 10 Mounts

Step 7: SSL Certificate and Alert Configuration

SSL monitoring:

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

Alert thresholds:

1. Go to Alert Channels and add Slack, email, or a webhook.
2. Web interface monitor: Consecutive failures before alert → 2 (Flame occasionally restarts on config reload).
3. API monitors: Consecutive failures before alert → 2.
4. TCP port monitor: Consecutive failures before alert → 1.
5. All heartbeat monitors alert automatically after one missed interval.

Maintenance window during updates:

# Suppress alerts during Flame container updates
curl -X POST https://vigilmon.online/api/maintenance \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"monitor_id": "FLAME_MONITOR_ID", "duration_minutes": 5}'

docker pull pawelmalak/flame:latest
docker compose up -d flame

Summary

| Monitor | Target | What It Catches | |---|---|---| | HTTP web interface | https://start.yourdomain.com | Flame process crash, container exit | | Keyword match | "Flame" in HTML | App loads but content fails | | HTTP API /api/apps | REST API endpoint | Backend API failure | | HTTP API /api/bookmarks | Bookmark sync endpoint | Bookmark feature broken | | Docker integration heartbeat | Docker socket + container check | Docker socket permission loss | | Weather API heartbeat | External API connectivity | API key expired, outbound network loss | | SQLite integrity heartbeat | Database PRAGMA integrity_check | Corrupted or locked database | | TCP port | Port 5005 | Node.js process not listening | | SSL certificate | Public domain | Let's Encrypt renewal failure |

Your Flame dashboard is the first thing you open when you sit down at your homelab — when it's down, you lose your navigation layer for everything else. With Vigilmon monitoring the application, API, Docker integration, and database, you'll know about failures before they interrupt your workflow.