const withTimeout = (promise, timeoutMs, name) => {
let timer;
const timeout = new Promise((_, reject) => {
timer = setTimeout(
() => reject(new Error(`check '${name}' timed out after ${timeoutMs}ms`)),
timeoutMs
);
});
return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
};
class ChecksRegistry {
constructor({ defaultTimeoutMs = 2000 } = {}) {
this.defaultTimeoutMs = defaultTimeoutMs;
this.checks = new Map();
}
register(name, fn, { timeoutMs } = {}) {
if (this.checks.has(name)) {
throw new Error(`check '${name}' already registered`);
}
this.checks.set(name, { fn, timeoutMs: timeoutMs || this.defaultTimeoutMs });
return this;
}
async runAll() {
const entries = [...this.checks.entries()];
const settled = await Promise.allSettled(
entries.map(async ([name, { fn, timeoutMs }]) => {
const start = Date.now();
const result = await withTimeout(Promise.resolve().then(fn), timeoutMs, name);
return { name, durationMs: Date.now() - start, ...result };
})
);
return settled.map((outcome, i) => {
const name = entries[i][0];
if (outcome.status === 'fulfilled') {
return { name, status: outcome.value.status || 'up', ...outcome.value };
}
return { name, status: 'down', durationMs: null, error: outcome.reason.message };
});
}
}
module.exports = { ChecksRegistry, withTimeout };
const os = require('os');
const postgresCheck = (pool) => async () => {
const client = await pool.connect();
try {
await client.query('SELECT 1');
return { status: 'up' };
} finally {
client.release();
}
};
const redisCheck = (redis) => async () => {
const reply = await redis.ping();
if (reply !== 'PONG') {
throw new Error(`unexpected PING reply: ${reply}`);
}
return { status: 'up' };
};
const diskCheck = ({ minFreeBytes = 512 * 1024 * 1024 } = {}) => async () => {
const freeBytes = os.freemem();
if (freeBytes < minFreeBytes) {
return { status: 'degraded', freeBytes, minFreeBytes };
}
return { status: 'up', freeBytes };
};
module.exports = { postgresCheck, redisCheck, diskCheck };
const express = require('express');
const { ChecksRegistry } = require('./checksRegistry');
const { postgresCheck, redisCheck, diskCheck } = require('./checks');
const overallStatus = (results) => {
if (results.some((r) => r.status === 'down')) return 'down';
if (results.some((r) => r.status === 'degraded')) return 'degraded';
return 'up';
};
function createHealthRouter({ pool, redis }) {
const registry = new ChecksRegistry({ defaultTimeoutMs: 2000 });
registry
.register('postgres', postgresCheck(pool))
.register('redis', redisCheck(redis), { timeoutMs: 1000 })
.register('disk', diskCheck());
const router = express.Router();
// Liveness must not depend on downstream services.
router.get('/live', (_req, res) => {
res.json({ status: 'up', pid: process.pid, uptime: process.uptime() });
});
router.get('/ready', async (_req, res) => {
const checks = await registry.runAll();
const status = overallStatus(checks);
res.status(status === 'down' ? 503 : 200).json({
status,
checks,
timestamp: new Date().toISOString(),
});
});
return router;
}
module.exports = { createHealthRouter };
This snippet builds a production-style health-check endpoint for an Express service by separating three concerns: a registry of named checks, the individual dependency probes, and the router that aggregates them. The core idea is that liveness and readiness are not one boolean but the composition of many independent probes, each of which can succeed, fail, or time out on its own.
In checksRegistry.js, a ChecksRegistry stores probe functions keyed by name and exposes runAll. Each probe is wrapped in withTimeout so a hung dependency (a stuck TCP connect, a slow query) cannot stall the whole endpoint — an unresolved probe rejects after timeoutMs instead of hanging the request forever. Probes are executed concurrently via Promise.allSettled, so one failure never short-circuits the others and every dependency still reports its own status. Each result is normalized into { name, status, durationMs, error }, and a probe is allowed to mark itself degraded (reachable but slow or partial) rather than a hard down.
Probes themselves live in checks.js. postgresCheck runs a trivial SELECT 1, redisCheck issues a PING, and diskCheck demonstrates a degraded result when free space drops below a threshold. Each is just an async function returning a status, which keeps them trivially unit-testable and decoupled from the transport.
In healthRouter.js, the registry is populated once at wiring time. The router exposes /live as a cheap liveness probe that only confirms the process is up — crucial because a liveness failure typically triggers a pod restart, so it must not depend on downstream services. /ready calls registry.runAll, then folds the individual statuses into an overall verdict: any down yields 503, any degraded still returns 200 but flags the condition, and the full breakdown is returned as JSON for dashboards and probes to scrape.
The key trade-off is that readiness aggregation is only as good as its timeouts and its down/degraded classification; too aggressive and healthy nodes flap out of rotation, too lenient and traffic routes to a broken instance. Reaching for this pattern makes sense whenever a service has several external dependencies and needs Kubernetes, a load balancer, or an uptime monitor to distinguish 'restart me' from 'don't send me traffic yet'.
Related snips
package api
import (
"net/http"
"runtime/debug"
)Expose build metadata for debugging deploys
export interface RetryOptions {
retries: number;
baseMs: number;
maxMs: number;
signal?: AbortSignal;
onRetry?: (attempt: number, delay: number, err: unknown) => void;Exponential backoff with jitter for retries
package dbutil
import (
"context"
"github.com/jackc/pgconn"Retry Postgres serialization failures with bounded attempts
use tracing::{info, instrument};
#[instrument]
fn process_request(user_id: u64) {
info!(user_id, "Processing request");
// Work happens heretracing for structured logging and distributed tracing
import { randomBytes, createHash } from "crypto";
import jwt from "jsonwebtoken";
import { RefreshTokenStore } from "./store";
const ACCESS_SECRET = process.env.ACCESS_SECRET!;
const ACCESS_TTL = "15m";JWT access + refresh token rotation (conceptual)
import pandas as pd
from sklearn.ensemble import IsolationForest
df = pd.read_csv('service_metrics.csv')
features = df[['latency_p95', 'error_rate', 'throughput', 'cpu_utilization']]Anomaly detection with isolation forest and robust thresholds
Share this code
Here's the card — post it anywhere.
