Hybrids is a unique UI library for creating web components from plain objects and pure functions — no classes, no decorators, just straightforward JavaScript objects with property descriptors. But that simplicity disappears entirely the moment your app is down, your API is unreachable, or a background task is silently failing. Vigilmon gives you the visibility layer you need: continuous HTTP monitoring, heartbeat checks, and instant alerts routed to email or Slack.
What You'll Build
- A health API endpoint for your Hybrids backend
- Vigilmon HTTP monitors for your Hybrids app and backend
- A heartbeat for scheduled background tasks
- Alert channels (email and Slack)
- An uptime badge as a reusable Hybrids web component
Prerequisites
- A Hybrids project (
npm install hybrids) - Node.js/Express backend for the health endpoint
- A free Vigilmon account
Step 1: Add a Health Endpoint
Hybrids apps are SPAs backed by a separate server. Add a /health route to your Express backend:
// server.js
import express from "express";
const app = express();
app.get("/health", async (req, res) => {
const checks = {};
let degraded = false;
// Database check
try {
// await db.query("SELECT 1");
checks.database = "ok";
} catch (err) {
checks.database = `error: ${err.message}`;
degraded = true;
}
// Cache check
try {
// await redisClient.ping();
checks.cache = "ok";
} catch (err) {
checks.cache = `error: ${err.message}`;
degraded = true;
}
res.status(degraded ? 503 : 200).json({
status: degraded ? "degraded" : "ok",
timestamp: new Date().toISOString(),
checks,
});
});
// Serve Hybrids SPA
app.use(express.static("dist"));
app.get("*", (req, res) => res.sendFile("dist/index.html", { root: "." }));
app.listen(process.env.PORT ?? 3000);
Test it:
curl http://localhost:3000/health | jq .
# {"status":"ok","timestamp":"2026-06-29T...","checks":{"database":"ok","cache":"ok"}}
Step 2: Configure Vigilmon HTTP Monitors
Log in to Vigilmon → Monitors → New Monitor:
Monitor 1: Hybrids SPA
| Field | Value |
|---|---|
| URL | https://yourapp.com/ |
| Method | GET |
| Expected status | 200 |
| Expected body | A stable string from your HTML (e.g. app title) |
| Check interval | 1 minute |
Monitor 2: Health API
| Field | Value |
|---|---|
| URL | https://yourapp.com/health |
| Method | GET |
| Expected status | 200 |
| Check interval | 1 minute |
With both monitors, you cover two independent failure classes: the static/CDN serving layer and the backend/data layer.
Step 3: Heartbeat for Background Tasks
Background jobs — data sync, webhook delivery, session cleanup — can fail silently for days without anyone noticing. A Vigilmon heartbeat catches this by alerting when the expected ping doesn't arrive.
npm install node-cron
// scheduler.js
import cron from "node-cron";
const VIGILMON_HEARTBEAT_URL = process.env.VIGILMON_HEARTBEAT_URL ?? "";
async function pingHeartbeat() {
if (!VIGILMON_HEARTBEAT_URL) return;
try {
await fetch(VIGILMON_HEARTBEAT_URL, { signal: AbortSignal.timeout(5000) });
} catch {
// Monitoring must never crash the job
}
}
cron.schedule("*/10 * * * *", async () => {
try {
await syncData();
await pingHeartbeat();
} catch (err) {
console.error("[scheduler] Data sync failed:", err);
// Vigilmon alerts after the heartbeat window expires with no ping
}
});
async function syncData() {
// Your actual data sync logic
}
Set up the heartbeat in Vigilmon:
- Monitors → New Heartbeat Monitor
- Set Expected interval to 20 minutes (2× the cron interval for a grace window)
- Copy the ping URL to your
.env:
VIGILMON_HEARTBEAT_URL=https://vigilmon.online/api/heartbeat/xxxxxxxx
Step 4: Display Uptime Status as a Hybrids Web Component
Hybrids lets you define custom elements as plain objects. Here's a status-badge component:
// src/components/status-badge.js
import { define, html } from "hybrids";
const StatusBadge = {
badgeUrl: "https://vigilmon.online/api/badge/your-monitor-id.svg",
statusUrl: "https://vigilmon.online/status/your-monitor-slug",
render: ({ badgeUrl, statusUrl }) => html`
<a
href="${statusUrl}"
target="_blank"
rel="noopener noreferrer"
aria-label="Service uptime status"
>
<img
src="${badgeUrl}"
alt="Uptime"
width="120"
height="20"
/>
</a>
`,
};
define({ tag: "status-badge", ...StatusBadge });
Use it in your HTML or another Hybrids component:
<!-- index.html -->
<script type="module" src="./src/components/status-badge.js"></script>
<footer>
<status-badge></status-badge>
</footer>
Or compose it into your app shell component:
// src/components/app-shell.js
import { define, html } from "hybrids";
import "./status-badge.js";
const AppShell = {
render: () => html`
<div class="app">
<main>
<slot></slot>
</main>
<footer class="footer">
<status-badge></status-badge>
</footer>
</div>
`,
};
define({ tag: "app-shell", ...AppShell });
Step 5: Set Up Alert Channels
In Vigilmon's Alert Channels settings:
- Alert Channels → Email → add your on-call email
- Attach to both HTTP monitors and the heartbeat
Slack
- Create a Slack Incoming Webhook for
#alerts - Alert Channels → Webhook → paste the URL
- Payload template:
{
"text": "🚨 *{{ monitor.name }}* is DOWN\n{{ monitor.url }}\nStatus: {{ event.status }}\n<https://vigilmon.online|Open Vigilmon>"
}
Step 6: Verify Everything Works
# 1. Health endpoint responds correctly
curl -s https://yourapp.com/health | jq .
# 2. Simulate DB failure → confirm health returns 503
# Expected: Vigilmon alerts within 2 minutes
# 3. Remove VIGILMON_HEARTBEAT_URL → let the scheduler run
# Expected: heartbeat alert fires after the grace window
# 4. Vigilmon → "Test Alert" → confirm delivery to Slack/email
Summary
| Monitor | What It Catches | |---|---| | HTTP SPA check | CDN failures, broken static deploys | | HTTP health API | Database and cache failures | | Heartbeat | Scheduler crashes, silent sync failures |
Next Steps
- Create separate monitors for staging vs. production
- Use Vigilmon's response time graphs to spot latency regressions
- Configure multi-channel alerting: email for low-severity, Slack for critical
Ready to get started? Sign up for Vigilmon free — have your first monitor running in under 5 minutes.