Uptime monitoring for Glance self-hosted dashboard

Glance is a self-hosted dashboard built in Go that aggregates live data from RSS feeds, GitHub, Reddit, weather APIs, and dozens of other sources into a single configurable page. It is the kind of tool people open first thing every morning — so when it is down or feeds are broken, users notice immediately. Because Glance pulls from many external APIs, failures can come from the web server itself, a single widget's data source, or the configuration reload service.

This tutorial covers production-grade uptime monitoring for Glance using Vigilmon. We will walk through:

Monitoring Glance web server uptime on port 8080
Monitoring widget feed fetch health
Monitoring external API connectivity for each data source
Monitoring configuration reload service
Monitoring dashboard page load performance

Prerequisites

Glance running on port 8080 (Docker or bare metal)
A free account at vigilmon.online

Part 1: Monitor the Glance web server

Glance serves its dashboard on port 8080. Monitoring the root URL confirms the Go HTTP server is running and the dashboard page renders correctly.

Deploy Glance with Docker Compose

# docker-compose.yml
version: "3.8"

services:
  glance:
    image: glanceapp/glance:latest
    ports:
      - "8080:8080"
    volumes:
      - ./glance.yml:/app/glance.yml:ro
    restart: unless-stopped

Verify the web server

curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/
# Expected: 200

Vigilmon setup for the Glance web server

Log in to vigilmon.online and click Add Monitor.
Choose HTTP(S) monitor.
Enter: http://your-glance-host:8080/
Set interval to 1 minute.
Add a keyword check: must contain Glance (or a known title from your dashboard HTML).
Name it Glance Dashboard.
Click Save.

The keyword check confirms the Go template rendered the actual dashboard page, not a generic 200 from an error handler or load balancer.

Part 2: Monitor widget feed health

Glance fetches data from RSS, Reddit, GitHub, and other sources on a configurable schedule. If a widget feed fetch fails repeatedly, the dashboard shows stale or empty data. While Glance degrades gracefully per widget, a systematic feed failure is worth alerting on.

Sample Glance configuration

# glance.yml
pages:
  - name: Home
    columns:
      - size: small
        widgets:
          - type: rss
            title: Tech News
            feeds:
              - url: https://hnrss.org/frontpage
              - url: https://lobste.rs/rss
          - type: weather
            location: New York, NY
          - type: reddit
            subreddit: selfhosted
      - size: full
        widgets:
          - type: github-releases
            repositories:
              - glanceapp/glance
              - immich-app/immich

Monitor feed sources directly

The most reliable approach is to monitor the upstream feed URLs directly, in addition to the Glance web server. This lets you distinguish "Glance is down" from "one feed source is down":

| Widget type | Monitor URL | Keyword | |-------------|-------------|---------| | RSS (HN) | https://hnrss.org/frontpage | <rss | | Reddit | https://www.reddit.com/r/selfhosted/.rss | <feed | | Weather API | https://wttr.in/New+York?format=j1 | current_condition |

Create one HTTP monitor per critical feed in Vigilmon, labeled clearly (Glance RSS Source — HN, Glance Reddit Feed, etc.).

Part 3: Monitor external API connectivity

Glance integrates with GitHub, Twitch, and other external APIs that require authentication tokens. Token expiry, rate limiting, or API outages cause silent widget failures that are hard to diagnose from the dashboard alone.

GitHub API connectivity

# Test GitHub API reachability (no auth — checks connectivity only)
curl -s -o /dev/null -w "%{http_code}" https://api.github.com/repos/glanceapp/glance
# Expected: 200

Set up API connectivity monitors in Vigilmon

Click Add Monitor.
Choose HTTP(S) monitor.
Enter: https://api.github.com/
Set interval to 5 minutes (GitHub API rate limits apply to unauthenticated checks).
Set expected status code to 200.
Name it Glance — GitHub API.
Click Save.

Repeat for each external API your widgets depend on. Keep these on a longer interval (5–10 minutes) to avoid hitting external rate limits.

Part 4: Monitor the configuration reload service

Glance watches its configuration file for changes and reloads without restarting. If the config-reload watcher stalls (typically after a SIGHUP or a corrupt config write), the running dashboard may drift from the intended configuration.

Monitor Glance's response after a known configuration change by watching for a page title or widget that matches expectations:

# Check that the dashboard title is still set correctly
curl -s http://localhost:8080/ | grep -c "Home"
# Expected: 1 or more matches

Vigilmon keyword monitor for config integrity

Click Add Monitor.
Choose HTTP(S) monitor.
Enter: http://your-glance-host:8080/
Set interval to 5 minutes.
Add a keyword check: must contain Home (or the name of your first page in glance.yml).
Name it Glance Config Integrity.
Click Save.

If the keyword disappears — because the config failed to reload or a page name changed unexpectedly — this monitor fires a DOWN alert.

Part 5: Monitor dashboard page load performance

Because Glance fetches external data on each page render (for uncached widgets), dashboard response time is a good proxy for the health of its external integrations. A slow dashboard usually means one or more upstream feeds are timing out.

Enable response time monitoring in Vigilmon

Vigilmon records response times for every HTTP monitor check. To surface performance regressions:

Open the Glance Dashboard monitor you created in Part 1.
Click Edit.
Under Alerting, enable Response time alert.
Set threshold to 5000 ms (Glance with external widgets can be slow on first load).
Click Save.

You can view response time history in the Vigilmon dashboard for any monitor. If response times trend upward, check which widget feed is slowing down.

Part 6: SSL certificate monitoring

If Glance is exposed through a reverse proxy with TLS, monitor the certificate to catch renewal failures:

In Vigilmon, click Add Monitor.
Choose SSL monitor.
Enter: glance.example.com
Set alert threshold to 14 days before expiry.
Add your alert channel.
Click Save.

Part 7: Webhook alerts

Configure Vigilmon webhooks to notify your team when the Glance dashboard goes down:

// webhook-receiver.ts
import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhook/vigilmon', (req, res) => {
  const { monitor_name, status, url, response_code, response_time_ms, checked_at } = req.body;

  if (status === 'down') {
    console.error('[VIGILMON] Glance monitor DOWN', {
      monitor: monitor_name,
      url,
      code: response_code,
      responseTime: response_time_ms,
      at: checked_at,
    });

    notifyTeam({ monitor: monitor_name, url });
  } else if (status === 'up') {
    console.info('[VIGILMON] Glance recovered', { monitor: monitor_name });
  }

  res.sendStatus(204);
});

Vigilmon sends this payload on DOWN and UP transitions:

{
  "monitor_id": "mon_def456",
  "monitor_name": "Glance Dashboard",
  "status": "down",
  "url": "http://your-glance-host:8080/",
  "checked_at": "2026-06-30T09:15:00Z",
  "response_code": 503,
  "response_time_ms": 30000
}

Summary

Your Glance deployment now has four layers of monitoring:

Web server uptime — confirms Glance is serving the dashboard page on port 8080.
Widget feed health — monitors each upstream RSS, Reddit, and external feed independently.
External API connectivity — catches GitHub and other API outages before they silently break widgets.
Performance monitoring — surfaces slow dashboard loads caused by upstream feed timeouts.

Vigilmon handles check scheduling, multi-region polling, alert routing, and uptime history. You get notified within 60 seconds of any failure in your Glance stack.

Monitor your Glance dashboard free at vigilmon.online

#glance #selfhosted #dashboard #devops #monitoring