Add small trend lines to the rows of the server, endpoint and integration lists
Server cards show load and memory over the last 24 hours, endpoint checks show their answer times with a tick where a check failed, and integrations that keep a figure history show their headline figure over the last week. Each list asks for all its lines in one request, drawn from the history already kept, and each line has a sentence for screen readers. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
5750350565
commit
639408c0d0
15 files changed
+707
No files matched your search
@@ -11,6 +11,7 @@ import { sealSecret } from "../services/sealed.js";
|
||||
import { VALUE_OPS, valueProblem } from "../services/valueCheck.js";
|
||||
import { loadDismissed, loadSuggestions, saveDismissed } from "../services/endpointSuggestions.js";
|
||||
import { asyncHandler } from "../utils/asyncHandler.js";
|
||||
import { endpointSparklines } from "../services/sparklines.js";
|
||||
|
||||
export const endpointsRouter = Router();
|
||||
|
||||
@@ -86,6 +87,11 @@ endpointsRouter.get("/", asyncHandler(async (_req, res) => {
|
||||
});
|
||||
}));
|
||||
|
||||
// How long each check took to answer over the last day (and when one failed), as short series for the lines in the list.
|
||||
endpointsRouter.get("/sparklines", asyncHandler(async (_req, res) => {
|
||||
res.json({ hours: 24, checks: await endpointSparklines() });
|
||||
}));
|
||||
|
||||
// How one check has done over a day, a week, a month, three months or a year: availability and answer times, for the chart on its page.
|
||||
endpointsRouter.get("/:id/history", asyncHandler(async (req, res) => {
|
||||
const id = /^\d+$/.test(req.params.id) ? Number(req.params.id) : NaN;
|
||||
|
||||
@@ -31,6 +31,7 @@ import { dockerVulnSyncStatuses, findingsOf, imageAgeDays, imagesOf, isDockerVul
|
||||
import { invalidateAlertsCache } from "../services/alerts.js";
|
||||
import { forgetReading, readAfterChange, readIntegrationNow } from "../services/integrationSyncs.js";
|
||||
import { getIntegrationFigures, hasFigures } from "../services/integrationFigures.js";
|
||||
import { integrationSparklines } from "../services/sparklines.js";
|
||||
import { getSettings, updateSettings } from "../services/settingsStore.js";
|
||||
import { asyncHandler } from "../utils/asyncHandler.js";
|
||||
import { ID_PATTERNS, isValidId } from "../utils/pathSegment.js";
|
||||
@@ -45,6 +46,11 @@ integrationsRouter.get("/fields", (_req, res) => {
|
||||
res.json({ fields: INTEGRATION_FIELDS });
|
||||
});
|
||||
|
||||
// The figure each integration is known for, over the last week, as short series for the lines in the list (the full history is /:id/figures).
|
||||
integrationsRouter.get("/sparklines", asyncHandler(async (_req, res) => {
|
||||
res.json({ days: 7, integrations: await integrationSparklines() });
|
||||
}));
|
||||
|
||||
integrationsRouter.get("/", asyncHandler(async (_req, res) => {
|
||||
const rows = await db
|
||||
.select({
|
||||
|
||||
@@ -27,6 +27,7 @@ import { invalidateAlertsCache } from "../services/alerts.js";
|
||||
import { getSettings, updateSettings } from "../services/settingsStore.js";
|
||||
import { osSummary } from "../services/osLifecycle.js";
|
||||
import { normaliseHostname } from "../utils/hostnames.js";
|
||||
import { serverSparklines } from "../services/sparklines.js";
|
||||
|
||||
export const serversRouter = Router();
|
||||
|
||||
@@ -253,6 +254,11 @@ serversRouter.patch("/:id", requireRole("admin"), asyncHandler(async (req, res)
|
||||
|
||||
// For the dashboard widget. Computed here, with the health monitor's own rules and the thresholds from Settings
|
||||
// (which viewers can't read), so the widget and the alerts always agree about what "offline" and "full" mean.
|
||||
// The last day's load and memory of every server that reports them, as short series for the lines in a list. Anyone signed in, like the list itself.
|
||||
serversRouter.get("/sparklines", asyncHandler(async (_req, res) => {
|
||||
res.json({ hours: 24, servers: await serverSparklines() });
|
||||
}));
|
||||
|
||||
serversRouter.get("/summary", asyncHandler(async (_req, res) => {
|
||||
const rows = await db
|
||||
.select({ id: servers.id, name: servers.name, osType: servers.osType, lastSeenAt: servers.lastSeenAt, disks: servers.disks, thresholds: servers.thresholds })
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
/**
|
||||
* Short series for the small lines in the rows of a list — a server's load and memory over the last day, how long an endpoint took to answer (and when it did not), the figure an integration is
|
||||
* known for over the last week — so a list says not only how things are but which way they are going. Every one is worked out for all rows at once, in the database, so a list asks once.
|
||||
*
|
||||
* A series is a fixed number of equal slices from `from` to now, each the average of what was read in it, or null where nothing was (a gap is a gap, not a line through it). Nothing here is new data:
|
||||
* it is the history the app already keeps (services/serverMetrics.ts, services/endpointChecks.ts, services/integrationFigures.ts).
|
||||
*/
|
||||
import { sql } from "drizzle-orm";
|
||||
import { db } from "../db/client.js";
|
||||
|
||||
export const SLICES = 24;
|
||||
const HOUR_MS = 3600_000;
|
||||
|
||||
const round1 = (n: number) => Math.round(n * 10) / 10;
|
||||
|
||||
/** A column holding an ISO time, as the number of the slice it falls in (0 at `fromMs`): the work done in SQL so a list is one query. */
|
||||
const sliceOf = (column: string, fromMs: number, sliceMs: number) => sql.raw(`cast((strftime('%s', ${column}) * 1000 - ${Math.round(fromMs)}) / ${Math.round(sliceMs)} as integer)`);
|
||||
|
||||
/** Slices of (slice number → value) into a full list of `n` values, null where there is none. Pure. */
|
||||
export function fillSlices(found: Map<number, number>, n: number = SLICES): (number | null)[] {
|
||||
return Array.from({ length: n }, (_, i) => (found.has(i) ? round1(found.get(i)!) : null));
|
||||
}
|
||||
|
||||
export interface Spark {
|
||||
/** `SLICES` values, oldest first; null for a slice with nothing in it. */
|
||||
values: (number | null)[];
|
||||
/** The last value there is. */
|
||||
latest: number | null;
|
||||
low: number | null;
|
||||
high: number | null;
|
||||
}
|
||||
|
||||
/** A series with its last, lowest and highest value worked out; null when there is not one value in it. */
|
||||
export function sparkOf(values: (number | null)[]): Spark | null {
|
||||
const real = values.filter((v): v is number => v !== null);
|
||||
if (real.length === 0) return null;
|
||||
return { values, latest: real[real.length - 1], low: Math.min(...real), high: Math.max(...real) };
|
||||
}
|
||||
|
||||
// ─── Servers ──────────────────────────────────────────────────────────────
|
||||
|
||||
export type ServerSparklines = Record<number, { cpu?: Spark; mem?: Spark }>;
|
||||
|
||||
/** Load and memory of every server that reports them, over the last `hours` (an agent-reported figure, as a percentage). */
|
||||
export async function serverSparklines(now: Date = new Date(), hours = 24): Promise<ServerSparklines> {
|
||||
const to = now.getTime();
|
||||
const from = to - hours * HOUR_MS;
|
||||
const sliceMs = (hours * HOUR_MS) / SLICES;
|
||||
const rows = await db.all<{ server_id: number; metric: string; slice: number; v: number }>(sql`
|
||||
SELECT server_id, metric, ${sliceOf("recorded_at", from, sliceMs)} AS slice, avg(value) AS v
|
||||
FROM server_metrics
|
||||
WHERE recorded_at >= ${new Date(from).toISOString()} AND metric IN ('cpu', 'mem')
|
||||
GROUP BY server_id, metric, slice`);
|
||||
const grouped = new Map<string, Map<number, number>>();
|
||||
for (const r of rows) {
|
||||
if (r.slice < 0 || r.slice >= SLICES) continue;
|
||||
const key = `${r.server_id}:${r.metric}`;
|
||||
if (!grouped.has(key)) grouped.set(key, new Map());
|
||||
grouped.get(key)!.set(r.slice, r.v);
|
||||
}
|
||||
const out: ServerSparklines = {};
|
||||
for (const [key, found] of grouped) {
|
||||
const [id, metric] = key.split(":");
|
||||
const spark = sparkOf(fillSlices(found));
|
||||
if (!spark) continue;
|
||||
(out[Number(id)] ??= {})[metric as "cpu" | "mem"] = spark;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// ─── Endpoints ────────────────────────────────────────────────────────────
|
||||
|
||||
export interface EndpointSpark extends Spark {
|
||||
/** For each slice: at least one check in it failed. */
|
||||
failed: boolean[];
|
||||
}
|
||||
export type EndpointSparklines = Record<number, EndpointSpark>;
|
||||
|
||||
/** How long each endpoint check took to answer over the last `hours` (milliseconds), and in which slices a check failed. */
|
||||
export async function endpointSparklines(now: Date = new Date(), hours = 24): Promise<EndpointSparklines> {
|
||||
const to = now.getTime();
|
||||
const from = to - hours * HOUR_MS;
|
||||
const sliceMs = (hours * HOUR_MS) / SLICES;
|
||||
const rows = await db.all<{ check_id: number; slice: number; ms: number | null; bad: number }>(sql`
|
||||
SELECT check_id, ${sliceOf("at", from, sliceMs)} AS slice, avg(CASE WHEN ok = 1 THEN ms END) AS ms, sum(CASE WHEN ok = 0 THEN 1 ELSE 0 END) AS bad
|
||||
FROM endpoint_results
|
||||
WHERE at >= ${new Date(from).toISOString()}
|
||||
GROUP BY check_id, slice`);
|
||||
const ms = new Map<number, Map<number, number>>();
|
||||
const bad = new Map<number, Set<number>>();
|
||||
for (const r of rows) {
|
||||
if (r.slice < 0 || r.slice >= SLICES) continue;
|
||||
if (!ms.has(r.check_id)) ms.set(r.check_id, new Map());
|
||||
if (r.ms !== null) ms.get(r.check_id)!.set(r.slice, r.ms);
|
||||
if (r.bad > 0) (bad.get(r.check_id) ?? bad.set(r.check_id, new Set()).get(r.check_id)!).add(r.slice);
|
||||
}
|
||||
const out: EndpointSparklines = {};
|
||||
for (const id of new Set([...ms.keys(), ...bad.keys()])) {
|
||||
const values = fillSlices(ms.get(id) ?? new Map());
|
||||
const failed = Array.from({ length: SLICES }, (_, i) => bad.get(id)?.has(i) ?? false);
|
||||
const spark = sparkOf(values) ?? { values, latest: null, low: null, high: null };
|
||||
out[id] = { ...spark, failed };
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// ─── Integrations ─────────────────────────────────────────────────────────
|
||||
|
||||
/** Which figure stands for an integration in a list: the first of these it has, else the first it was given. */
|
||||
export const HEADLINE_ORDER = ["cost", "queries", "queue", "speedDown", "photos", "documents", "users", "devices", "failed24h", "targetsDown", "firing", "failedLogins24h", "movies", "active"];
|
||||
|
||||
export interface IntegrationSpark extends Spark {
|
||||
key: string;
|
||||
label: string;
|
||||
unit: string;
|
||||
}
|
||||
export type IntegrationSparklines = Record<number, IntegrationSpark>;
|
||||
|
||||
/** Pure: the figure that stands for an integration, from the ones it has (in the order they were first kept). */
|
||||
export function headlineOf<T extends { key: string }>(figures: T[]): T | null {
|
||||
for (const key of HEADLINE_ORDER) {
|
||||
const f = figures.find((x) => x.key === key);
|
||||
if (f) return f;
|
||||
}
|
||||
return figures[0] ?? null;
|
||||
}
|
||||
|
||||
/** The headline figure of every integration that keeps history, over the last `days`. */
|
||||
export async function integrationSparklines(now: Date = new Date(), days = 7): Promise<IntegrationSparklines> {
|
||||
const to = now.getTime();
|
||||
const from = to - days * 24 * HOUR_MS;
|
||||
const sliceMs = (days * 24 * HOUR_MS) / SLICES;
|
||||
const figures = await db.all<{ id: number; integration_id: number; key: string; label: string; unit: string }>(sql`SELECT id, integration_id, key, label, unit FROM integration_figures ORDER BY id`);
|
||||
const byIntegration = new Map<number, typeof figures>();
|
||||
for (const f of figures) (byIntegration.get(f.integration_id) ?? byIntegration.set(f.integration_id, []).get(f.integration_id)!).push(f);
|
||||
const chosen = new Map<number, (typeof figures)[number]>();
|
||||
for (const [integrationId, list] of byIntegration) {
|
||||
const pick = headlineOf(list);
|
||||
if (pick) chosen.set(pick.id, pick);
|
||||
void integrationId;
|
||||
}
|
||||
if (chosen.size === 0) return {};
|
||||
const rows = await db.all<{ figure_id: number; slice: number; v: number }>(sql`
|
||||
SELECT figure_id, ${sliceOf("at", from, sliceMs)} AS slice, avg(value) AS v
|
||||
FROM integration_figure_samples
|
||||
WHERE at >= ${new Date(from).toISOString()}
|
||||
GROUP BY figure_id, slice`);
|
||||
const found = new Map<number, Map<number, number>>();
|
||||
for (const r of rows) {
|
||||
if (!chosen.has(r.figure_id) || r.slice < 0 || r.slice >= SLICES) continue;
|
||||
if (!found.has(r.figure_id)) found.set(r.figure_id, new Map());
|
||||
found.get(r.figure_id)!.set(r.slice, r.v);
|
||||
}
|
||||
const out: IntegrationSparklines = {};
|
||||
for (const [figureId, f] of chosen) {
|
||||
const spark = sparkOf(fillSlices(found.get(figureId) ?? new Map()));
|
||||
if (spark) out[f.integration_id] = { ...spark, key: f.key, label: f.label, unit: f.unit };
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* The drawing of the small lines in the rows of a list: where the points go, that a gap is a gap, that a lone reading is a dot, the fixed scale of a percentage, and the sentence for a screen reader.
|
||||
*
|
||||
* Run with: npm test --workspace server
|
||||
*/
|
||||
import { test, describe } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { sparkGeometry, sparkTicks, sparkWords } from "../../web/src/utils/sparkline.js";
|
||||
|
||||
describe("the points", () => {
|
||||
test("oldest at the left, newest at the right, the highest reading at the top; the last reading is marked", () => {
|
||||
const g = sparkGeometry([0, 50, 100], 100, 20, { min: 0, max: 100, pad: 2 });
|
||||
assert.deepEqual(g.lines, ["M2 18 L50 10 L98 2"]);
|
||||
assert.deepEqual(g.last, { x: 98, y: 2 });
|
||||
assert.deepEqual([g.min, g.max], [0, 100]);
|
||||
assert.deepEqual(g.dots, []);
|
||||
});
|
||||
|
||||
test("a gap in the data is a gap in the line, and a reading alone between gaps is a dot", () => {
|
||||
const g = sparkGeometry([10, 20, null, 40, null, 60, 70], 120, 20, { min: 0, max: 100 });
|
||||
assert.equal(g.lines.length, 2, "two runs of two");
|
||||
assert.equal(g.dots.length, 1, "and the lone 40");
|
||||
assert.ok(g.lines[0].startsWith("M2 "));
|
||||
assert.deepEqual(g.last, { x: 118, y: 6.8 }, "the last reading, 70 on a scale of 0 to 100");
|
||||
assert.equal(sparkGeometry([null, null, null], 100, 20).last, null);
|
||||
assert.deepEqual(sparkGeometry([null, null], 100, 20).lines, []);
|
||||
});
|
||||
|
||||
test("the scale fits the data unless it is fixed; a flat line is drawn through the middle, not along an edge", () => {
|
||||
const fitted = sparkGeometry([100, 300], 100, 20);
|
||||
assert.deepEqual([fitted.min, fitted.max], [100, 300]);
|
||||
assert.equal(fitted.lines[0], "M2 18 L98 2");
|
||||
const flat = sparkGeometry([5, 5, 5], 100, 20);
|
||||
assert.deepEqual(flat.lines, ["M2 10 L50 10 L98 10"]);
|
||||
// a fixed scale is not moved by the data, and a reading outside it stays inside the picture
|
||||
const percent = sparkGeometry([5, 5], 100, 20, { min: 0, max: 100 });
|
||||
assert.equal(percent.lines[0], "M2 17.2 L98 17.2");
|
||||
assert.equal(sparkGeometry([250], 100, 20, { min: 0, max: 100 }).dots[0].y, 2);
|
||||
});
|
||||
|
||||
test("one reading is one dot in the middle", () => {
|
||||
const g = sparkGeometry([42], 100, 20);
|
||||
assert.deepEqual(g.lines, []);
|
||||
assert.deepEqual(g.dots, [{ x: 50, y: 10 }]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the ticks and the words", () => {
|
||||
test("a tick under each stretch that is marked, at the place of that stretch", () => {
|
||||
assert.deepEqual(sparkTicks([false, true, false, true], 100), [34, 98]);
|
||||
assert.deepEqual(sparkTicks([false, false], 100), []);
|
||||
});
|
||||
|
||||
test("the sentence says what it is, over what, where it stands now, the range, and the failures", () => {
|
||||
const pct = (v: number) => `${Math.round(v)}%`;
|
||||
assert.equal(sparkWords("CPU load", "last 24 hours", 12, 3, 40, pct), "CPU load, last 24 hours: 12% now, between 3% and 40%");
|
||||
assert.equal(sparkWords("Disk", "last week", 50, 50, 50, pct), "Disk, last week: 50% now");
|
||||
assert.equal(sparkWords("Wiki", "answer time, last 24 hours", 30, 20, 90, (v) => `${v} ms`, 2), "Wiki, answer time, last 24 hours: 30 ms now, between 20 ms and 90 ms, 2 stretches with a failure");
|
||||
assert.equal(sparkWords("Wiki", "x", 30, 30, 30, pct, 1), "Wiki, x: 30% now, 1 stretch with a failure");
|
||||
assert.equal(sparkWords("Up", "last week", null, null, null, pct), "Up, last week: nothing read");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,205 @@
|
||||
/**
|
||||
* The small lines in the rows of a list: servers' load and memory over a day, how long endpoints took to answer (and when they failed), the figure an integration is known for over a week —
|
||||
* how the slices are made, that a gap stays a gap, which figure stands for an integration, and the three routes.
|
||||
*
|
||||
* Run with: npm test --workspace server
|
||||
*/
|
||||
import { test, describe, before, after } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import type { AddressInfo } from "node:net";
|
||||
import type { Server } from "node:http";
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), "hm-spark-"));
|
||||
process.env.DATABASE_PATH = join(dir, "test.sqlite");
|
||||
process.env.SESSION_DIR = join(dir, "sessions");
|
||||
process.env.CREDENTIALS_ENCRYPTION_KEY = "ab".repeat(32);
|
||||
process.env.HEALTH_STARTUP_GRACE_MS = "0";
|
||||
|
||||
const express = (await import("express")).default;
|
||||
const { db } = await import("../src/db/client.js");
|
||||
const { users, servers, serverMetrics, endpointChecks, endpointResults, integrations } = await import("../src/db/schema.js");
|
||||
const { runMigrations } = await import("../src/db/migrate.js");
|
||||
const S = await import("../src/services/sparklines.js");
|
||||
const { recordFigures } = await import("../src/services/integrationFigures.js");
|
||||
const { hashToken } = await import("../src/services/tokens.js");
|
||||
const { serversRouter } = await import("../src/routes/servers.js");
|
||||
const { endpointsRouter } = await import("../src/routes/endpoints.js");
|
||||
const { integrationsRouter } = await import("../src/routes/integrations.js");
|
||||
|
||||
await runMigrations();
|
||||
|
||||
const NOW = new Date("2026-11-10T12:00:00.000Z");
|
||||
const hoursAgo = (h: number) => new Date(NOW.getTime() - h * 3600_000);
|
||||
|
||||
describe("making a series", () => {
|
||||
test("a fixed number of slices, oldest first, null where nothing was read", () => {
|
||||
const filled = S.fillSlices(new Map([[0, 10.04], [3, 20], [23, 7]]));
|
||||
assert.equal(filled.length, S.SLICES);
|
||||
assert.deepEqual([filled[0], filled[1], filled[3], filled[23]], [10, null, 20, 7]);
|
||||
assert.equal(S.fillSlices(new Map(), 5).join(), ",,,,");
|
||||
});
|
||||
|
||||
test("a series knows its last, lowest and highest value, and no series is no spark", () => {
|
||||
assert.deepEqual(S.sparkOf([null, 5, null, 9, 2, null]), { values: [null, 5, null, 9, 2, null], latest: 2, low: 2, high: 9 });
|
||||
assert.equal(S.sparkOf([null, null]), null);
|
||||
});
|
||||
|
||||
test("the figure that stands for an integration is the first of the known ones it has, else its first", () => {
|
||||
assert.equal(S.headlineOf([{ key: "servers" }, { key: "cost" }])!.key, "cost");
|
||||
assert.equal(S.headlineOf([{ key: "blocked" }, { key: "queries" }])!.key, "queries");
|
||||
assert.equal(S.headlineOf([{ key: "odd" }, { key: "other" }])!.key, "odd");
|
||||
assert.equal(S.headlineOf([]), null);
|
||||
});
|
||||
});
|
||||
|
||||
describe("servers", () => {
|
||||
let a = 0;
|
||||
let b = 0;
|
||||
before(async () => {
|
||||
[{ id: a }] = await db.insert(servers).values({ name: "spark-a", apiTokenHash: hashToken("sa"), apiTokenPrefix: "sa" }).returning({ id: servers.id });
|
||||
[{ id: b }] = await db.insert(servers).values({ name: "spark-b", apiTokenHash: hashToken("sb"), apiTokenPrefix: "sb" }).returning({ id: servers.id });
|
||||
const rows = [];
|
||||
// a: load rises through the day, memory flat, nothing in the middle hours
|
||||
for (const h of [23.5, 22.5, 20.5, 2.5, 1.5, 0.5]) {
|
||||
rows.push({ serverId: a, metric: "cpu", value: 100 - h * 4, recordedAt: hoursAgo(h).toISOString() });
|
||||
rows.push({ serverId: a, metric: "mem", value: 50, recordedAt: hoursAgo(h).toISOString() });
|
||||
}
|
||||
// b: a disk figure only (not one of the lines), and a reading from two days ago (out of the stretch)
|
||||
rows.push({ serverId: b, metric: "disk:/", value: 80, recordedAt: hoursAgo(1).toISOString() });
|
||||
rows.push({ serverId: b, metric: "cpu", value: 99, recordedAt: hoursAgo(48).toISOString() });
|
||||
await db.insert(serverMetrics).values(rows);
|
||||
});
|
||||
|
||||
test("load and memory over the last day, a slice an hour; a gap is null; others are left out", async () => {
|
||||
const out = await S.serverSparklines(NOW);
|
||||
assert.deepEqual(Object.keys(out).map(Number), [a], "b has nothing in the last day that is drawn");
|
||||
const cpu = out[a].cpu!;
|
||||
assert.equal(cpu.values.length, S.SLICES);
|
||||
assert.equal(cpu.values[0], 6, "23.5 hours ago is the first slice: 100 − 94");
|
||||
assert.equal(cpu.values[3], 18, "20.5 hours ago is the fourth slice");
|
||||
assert.equal(cpu.values[8], null, "nothing sixteen hours in");
|
||||
assert.equal(cpu.latest, 98, "the newest reading, half an hour ago");
|
||||
assert.equal(cpu.values[23], 98);
|
||||
assert.deepEqual([cpu.low, cpu.high], [6, 98]);
|
||||
assert.ok(out[a].mem!.values.every((v) => v === null || v === 50));
|
||||
});
|
||||
|
||||
test("readings in the same slice are averaged", async () => {
|
||||
await db.insert(serverMetrics).values([
|
||||
{ serverId: a, metric: "cpu", value: 10, recordedAt: hoursAgo(10.9).toISOString() },
|
||||
{ serverId: a, metric: "cpu", value: 20, recordedAt: hoursAgo(10.2).toISOString() },
|
||||
]);
|
||||
const cpu = (await S.serverSparklines(NOW))[a].cpu!;
|
||||
assert.equal(cpu.values[13], 15);
|
||||
});
|
||||
});
|
||||
|
||||
describe("endpoints", () => {
|
||||
let up = 0;
|
||||
let flaky = 0;
|
||||
let quiet = 0;
|
||||
before(async () => {
|
||||
[{ id: up }] = await db.insert(endpointChecks).values({ name: "Up", kind: "tcp", target: "h", port: 1 }).returning({ id: endpointChecks.id });
|
||||
[{ id: flaky }] = await db.insert(endpointChecks).values({ name: "Flaky", kind: "tcp", target: "h", port: 2 }).returning({ id: endpointChecks.id });
|
||||
[{ id: quiet }] = await db.insert(endpointChecks).values({ name: "Quiet", kind: "tcp", target: "h", port: 3 }).returning({ id: endpointChecks.id });
|
||||
const at = (h: number) => hoursAgo(h).toISOString();
|
||||
await db.insert(endpointResults).values([
|
||||
{ checkId: up, at: at(5.5), ok: true, ms: 40 },
|
||||
{ checkId: up, at: at(5.2), ok: true, ms: 60 },
|
||||
{ checkId: up, at: at(0.5), ok: true, ms: 30 },
|
||||
{ checkId: flaky, at: at(8.5), ok: true, ms: 100 },
|
||||
{ checkId: flaky, at: at(7.5), ok: false, ms: null },
|
||||
{ checkId: flaky, at: at(7.4), ok: false, ms: null },
|
||||
{ checkId: quiet, at: at(100), ok: true, ms: 5 },
|
||||
]);
|
||||
});
|
||||
|
||||
test("answer times by the hour for the last day; the ones that failed have no time but are marked", async () => {
|
||||
const out = await S.endpointSparklines(NOW);
|
||||
const u = out[up];
|
||||
assert.equal(u.values.length, S.SLICES);
|
||||
assert.equal(u.values[18], 50, "5.5 and 5.2 hours ago, averaged");
|
||||
assert.equal(u.latest, 30);
|
||||
assert.ok(u.failed.every((f) => !f));
|
||||
|
||||
const f = out[flaky];
|
||||
assert.equal(f.values[15], 100);
|
||||
assert.equal(f.values[16], null, "a failed check has no time");
|
||||
assert.equal(f.failed[16], true);
|
||||
assert.equal(f.failed[15], false);
|
||||
assert.equal(f.latest, 100, "the last time it did answer");
|
||||
});
|
||||
|
||||
test("a check with nothing in the last day is not in it", async () => {
|
||||
assert.equal((await S.endpointSparklines(NOW))[quiet], undefined);
|
||||
});
|
||||
});
|
||||
|
||||
describe("integrations", () => {
|
||||
let ag = 0;
|
||||
let nothing = 0;
|
||||
before(async () => {
|
||||
[{ id: ag }] = await db.insert(integrations).values({ type: "adguard", name: "AG", baseUrl: "http://x" }).returning({ id: integrations.id });
|
||||
[{ id: nothing }] = await db.insert(integrations).values({ type: "adguard", name: "No history", baseUrl: "http://y" }).returning({ id: integrations.id });
|
||||
for (let d = 6; d >= 0; d--) {
|
||||
await recordFigures(ag, [
|
||||
{ key: "blocked", label: "Blocked", unit: "count", value: 10 + d },
|
||||
{ key: "queries", label: "DNS queries", unit: "count", value: 100 * (7 - d) },
|
||||
], hoursAgo(d * 24 + 1));
|
||||
}
|
||||
});
|
||||
|
||||
test("the headline figure over the last week, a slice for each seven hours", async () => {
|
||||
const out = await S.integrationSparklines(NOW);
|
||||
assert.equal(out[nothing], undefined, "an integration with no history has no line");
|
||||
const s = out[ag];
|
||||
assert.deepEqual([s.key, s.label, s.unit], ["queries", "DNS queries", "count"]);
|
||||
assert.equal(s.values.length, S.SLICES);
|
||||
assert.equal(s.latest, 700);
|
||||
assert.equal(s.low, 100);
|
||||
assert.equal(s.values.filter((v) => v !== null).length, 7);
|
||||
});
|
||||
});
|
||||
|
||||
describe("the routes", () => {
|
||||
let app: Server;
|
||||
let base = "";
|
||||
before(async () => {
|
||||
await db.insert(users).values({ oidcSub: "viewer", name: "Vera", role: "viewer" });
|
||||
const a = express();
|
||||
a.use(express.json());
|
||||
a.use((req, _res, next) => {
|
||||
(req as unknown as { session: unknown }).session = { user: { sub: "viewer" } };
|
||||
next();
|
||||
});
|
||||
a.use("/api/servers", serversRouter);
|
||||
a.use("/api/endpoints", endpointsRouter);
|
||||
a.use("/api/integrations", integrationsRouter);
|
||||
app = await new Promise<Server>((resolve) => {
|
||||
const x = a.listen(0, "127.0.0.1", () => resolve(x));
|
||||
});
|
||||
base = `http://127.0.0.1:${(app.address() as AddressInfo).port}/api`;
|
||||
});
|
||||
after(() => {
|
||||
app.close();
|
||||
try {
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
} catch {
|
||||
// Windows keeps the database file locked until the process exits.
|
||||
}
|
||||
});
|
||||
|
||||
test("anyone signed in can ask for each; they answer in the shape the lists read, and are not mistaken for an id", async () => {
|
||||
for (const [path, key] of [["/servers/sparklines", "servers"], ["/endpoints/sparklines", "checks"], ["/integrations/sparklines", "integrations"]] as const) {
|
||||
const res = await fetch(`${base}${path}`);
|
||||
assert.equal(res.status, 200, path);
|
||||
const body = await res.json();
|
||||
assert.equal(typeof body[key], "object", path);
|
||||
assert.ok(!Array.isArray(body[key]));
|
||||
}
|
||||
// (their own data is old by now — the readings were made around a fixed day — so these are empty here; the figures are in the tests above)
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user