wehub-resource-sync
129 lines
4.4 KiB
TypeScript
Executable File
129 lines
4.4 KiB
TypeScript
Executable File
#!/usr/bin/env tsx
|
||
/**
|
||
* Load test simulating 50 keys × 5-minute cadence against a local or
|
||
* deployed showcase-harness (spec §9 Phase 5).
|
||
*
|
||
* For each iteration (default: 3), the script fires a burst of 50
|
||
* requests to each probed endpoint, records per-request latency, and
|
||
* prints a summary table of p50/p95/p99 per endpoint. Exit code 0 on
|
||
* success; non-zero when any percentile breaches a configurable
|
||
* threshold (see LOAD_TEST_MAX_MS, default 5000).
|
||
*
|
||
* Usage:
|
||
* tsx scripts/load-test.ts --url https://showcase-harness.railway.app
|
||
*
|
||
* Env overrides:
|
||
* LOAD_TEST_URL (alias for --url)
|
||
* LOAD_TEST_KEYS number of simulated keys per burst (default 50)
|
||
* LOAD_TEST_ITERATIONS number of bursts (default 3)
|
||
* LOAD_TEST_MAX_MS fail if p99 exceeds this (default 5000)
|
||
*/
|
||
|
||
interface EndpointSpec {
|
||
label: string;
|
||
path: string;
|
||
method?: "GET" | "POST";
|
||
body?: () => string;
|
||
headers?: Record<string, string>;
|
||
}
|
||
|
||
const ENDPOINTS: EndpointSpec[] = [
|
||
{ label: "GET /health", path: "/health" },
|
||
{ label: "GET /metrics", path: "/metrics" },
|
||
];
|
||
|
||
const args = process.argv.slice(2);
|
||
const urlFlagIdx = args.indexOf("--url");
|
||
const url =
|
||
(urlFlagIdx !== -1 ? args[urlFlagIdx + 1] : undefined) ??
|
||
process.env.LOAD_TEST_URL ??
|
||
"http://localhost:8080";
|
||
const keys = Number(process.env.LOAD_TEST_KEYS ?? "50");
|
||
const iterations = Number(process.env.LOAD_TEST_ITERATIONS ?? "3");
|
||
const maxMs = Number(process.env.LOAD_TEST_MAX_MS ?? "5000");
|
||
|
||
/**
|
||
* Nearest-rank percentile. Note `p=1.0` returns the last element (max), which
|
||
* is expected behavior for small n: with the default 50 requests/iteration,
|
||
* p99 effectively degenerates to the max. If that ambiguity matters, pass a
|
||
* larger LOAD_TEST_KEYS to get a stable p99.
|
||
*/
|
||
function percentile(sorted: number[], p: number): number {
|
||
if (sorted.length === 0) return 0;
|
||
const idx = Math.min(sorted.length - 1, Math.floor(p * sorted.length));
|
||
return sorted[idx]!;
|
||
}
|
||
|
||
async function measure(spec: EndpointSpec): Promise<number> {
|
||
const start = Date.now();
|
||
const res = await fetch(`${url}${spec.path}`, {
|
||
method: spec.method ?? "GET",
|
||
body: spec.body?.(),
|
||
headers: spec.headers,
|
||
});
|
||
// Drain response so the measurement includes body transfer.
|
||
await res.text();
|
||
if (!res.ok && res.status !== 404) {
|
||
throw new Error(`${spec.label} → HTTP ${res.status}`);
|
||
}
|
||
// 404 on /metrics is not fatal (some deploys disable the endpoint) but it
|
||
// IS operationally visible — warn so operators notice if they expected
|
||
// metrics to be enabled.
|
||
if (res.status === 404) {
|
||
console.warn(
|
||
`WARN: ${spec.label} returned 404 — endpoint disabled on this deploy?`,
|
||
);
|
||
}
|
||
return Date.now() - start;
|
||
}
|
||
|
||
async function runBurst(spec: EndpointSpec, count: number): Promise<number[]> {
|
||
const tasks: Promise<number>[] = [];
|
||
for (let i = 0; i < count; i++) {
|
||
tasks.push(measure(spec));
|
||
}
|
||
return Promise.all(tasks);
|
||
}
|
||
|
||
async function main(): Promise<void> {
|
||
console.log(
|
||
`load-test against ${url}: ${iterations} iterations × ${keys} keys`,
|
||
);
|
||
const perEndpoint = new Map<string, number[]>();
|
||
for (const ep of ENDPOINTS) perEndpoint.set(ep.label, []);
|
||
|
||
for (let i = 0; i < iterations; i++) {
|
||
for (const ep of ENDPOINTS) {
|
||
const timings = await runBurst(ep, keys);
|
||
perEndpoint.get(ep.label)!.push(...timings);
|
||
console.log(
|
||
` iter ${i + 1}/${iterations} ${ep.label}: ${timings.length} requests, min=${Math.min(...timings)}ms max=${Math.max(...timings)}ms`,
|
||
);
|
||
}
|
||
}
|
||
|
||
let failed = false;
|
||
console.log("\nper-endpoint latency percentiles (ms):");
|
||
console.log("endpoint p50 p95 p99 n");
|
||
console.log("-------------------------------- ------ ------ ------ -----");
|
||
for (const [label, timings] of perEndpoint) {
|
||
const sorted = [...timings].sort((a, b) => a - b);
|
||
const p50 = percentile(sorted, 0.5);
|
||
const p95 = percentile(sorted, 0.95);
|
||
const p99 = percentile(sorted, 0.99);
|
||
console.log(
|
||
`${label.padEnd(32)} ${String(p50).padStart(6)} ${String(p95).padStart(6)} ${String(p99).padStart(6)} ${String(sorted.length).padStart(5)}`,
|
||
);
|
||
if (p99 > maxMs) {
|
||
console.error(`FAIL: ${label} p99=${p99}ms exceeds threshold ${maxMs}ms`);
|
||
failed = true;
|
||
}
|
||
}
|
||
if (failed) process.exit(1);
|
||
}
|
||
|
||
main().catch((err) => {
|
||
console.error("load-test crashed:", err);
|
||
process.exit(2);
|
||
});
|