الـ Load Testing والـ Soak Testing: الـ server بيستحمل قد إيه بجد

// bench.js: الطريقة المشهورة: أربع connections، كل واحدة تبعت وتستنى وتبعت، و average
const URL = "http://localhost:3000/work";
const end = Date.now() + 3000;
const lat = [];
await Promise.all(Array.from({ length: 4 }, async () => {
  while (Date.now() < end) {
    const s = performance.now();
    await (await fetch(URL)).json();
    lat.push(performance.now() - s);
  }
}));
const avg = lat.reduce((a, b) => a + b, 0) / lat.length;
console.log(`${lat.length} request في تلات تواني ← ${(lat.length / 3).toFixed(0)} rps | average ${avg.toFixed(1)}ms`);

$ node --expose-gc server.js & S=$!; sleep 1; node bench.js; kill $S
on 3000
1468 request في تلات تواني ← 489 rps | average 8.1ms

// loadgen.js: load generator بـ closed loop و open loop، و percentiles، و slope للـ soak

export function percentile(values, p) {
  if (!values.length) return NaN;
  const s = [...values].sort((a, b) => a - b);
  return s[Math.min(s.length, Math.max(1, Math.ceil((p / 100) * s.length))) - 1];
}

export function summarize(lat, { errors = 0, durationMs }) {
  const total = lat.length + errors;
  const r = (x) => Math.round(x * 10) / 10;
  return {
    count: lat.length, errors, rps: Math.round(total / (durationMs / 1000)),
    p50: r(percentile(lat, 50)), p95: r(percentile(lat, 95)), p99: r(percentile(lat, 99)), max: r(Math.max(...lat)),
    errorRate: total ? errors / total : 0,
  };
}

const hit = async (url) => { const res = await fetch(url); await res.arrayBuffer(); if (res.status >= 500) throw new Error(String(res.status)); };

// closed loop: N users، كل واحد يبعت ويستنى الرد ويبعت تاني. لو الـ server وقف، هما كمان بيقفوا
export async function closedLoop({ url, concurrency, durationMs }) {
  const lat = []; let errors = 0;
  const start = performance.now(), end = start + durationMs;
  await Promise.all(Array.from({ length: concurrency }, async () => {
    while (performance.now() < end) {
      const s = performance.now();
      try { await hit(url); lat.push(performance.now() - s); } catch { errors++; }
    }
  }));
  return summarize(lat, { errors, durationMs: performance.now() - start });
}

// open loop: requests بتوصل بمعدل ثابت زي الـ users الحقيقيين، سواء الـ server رد ولا لأ
// والـ latency من الوقت اللي الـ request كان المفروض يتبعت فيه، مش من وقت ما اتبعت فعلًا
export async function openLoop({ url, rate, durationMs }) {
  const lat = []; let errors = 0;
  const start = performance.now(), gap = 1000 / rate, n = Math.floor((durationMs / 1000) * rate);
  const jobs = [];
  for (let i = 0; i < n; i++) {
    const intended = start + i * gap;
    const wait = intended - performance.now();
    if (wait > 1) await new Promise((r) => setTimeout(r, wait));
    jobs.push(hit(url).then(() => lat.push(performance.now() - intended), () => errors++));
  }
  await Promise.all(jobs);
  return summarize(lat, { errors, durationMs: performance.now() - start }); // الوقت الحقيقي لحد آخر رد ← الـ throughput الفعلي
}

// soak: هل الرقم ده بيطلع مع الوقت؟ least squares: الميل لكل تانية
export function slope(points) {
  const n = points.length;
  if (n < 2) return 0;
  const mt = points.reduce((a, p) => a + p.t, 0) / n, mv = points.reduce((a, p) => a + p.v, 0) / n;
  let num = 0, den = 0;
  for (const p of points) { num += (p.t - mt) * (p.v - mv); den += (p.t - mt) ** 2; }
  return den ? (num / den) * 1000 : 0; // t بالـ ms ← الميل لكل تانية
}

$ node --expose-gc server.js & S=$!; sleep 1; node load.js; kill $S
on 3000
closed loop أربعة       491 rps | p50 5.2ms | p99 31.8ms | max 317.9ms | errors 0
open loop مِيّتين/ث     200 rps | p50 5.1ms | p99 354.2ms | max 368.7ms | errors 0
open loop 400/ث         399 rps | p50 5.7ms | p99 409.9ms | max 429.3ms | errors 0
open loop 800/ث         587 rps | p50 301.3ms | p99 1921.5ms | max 1923.9ms | errors 0

// server.js: API عادي. كل تانية فيه pause تلتمية ms (زي GC كبير أو sync code)، و route بيسرّب memory
import express from "express";
import { randomBytes } from "node:crypto";

const app = express();
let inFlight = 0, maxInFlight = 0;
app.use((req, res, next) => {
  maxInFlight = Math.max(maxInFlight, ++inFlight);
  res.on("finish", () => inFlight--);
  next();
});
const busy = (ms) => { const end = performance.now() + ms; while (performance.now() < end); };

app.get("/work", async (req, res) => {
  busy(1); // شوية CPU
  await new Promise((r) => setTimeout(r, 3)); // و database
  res.json({ ok: true });
});
setInterval(() => busy(300), 1000).unref(); // الـ pause

const leak = [];
app.get("/leaky", (req, res) => {
  leak.push({ at: Date.now(), payload: randomBytes(4500).toString("base64") }); // كل request بيسيب حاجة وراه
  res.json({ ok: true });
});
app.get("/fail", (req, res) => res.status(503).json({ error: "down" }));
app.get("/stats", (req, res) => { if (req.query.reset) maxInFlight = 0; globalThis.gc?.(); res.json({ maxInFlight, heapMB: process.memoryUsage().heapUsed / 1048576 }); });
app.listen(3000, () => console.log("on 3000"));

// load.js: نفس الـ server بطريقتين، وبعدين open loop بمعدلات أعلى لحد ما يقع
import { closedLoop, openLoop } from "./loadgen.js";

const url = "http://localhost:3000/work";
const line = (name, r) => console.log(`${name.padEnd(22)} ${String(r.rps).padStart(4)} rps | p50 ${r.p50}ms | p99 ${r.p99}ms | max ${r.max}ms | errors ${r.errors}`);
line("closed loop أربعة", await closedLoop({ url, concurrency: 4, durationMs: 3000 }));
line("open loop مِيّتين/ث", await openLoop({ url, rate: 200, durationMs: 3000 }));
for (const rate of [400, 800]) line(`open loop ${rate}/ث`, await openLoop({ url, rate, durationMs: 2000 }));

// soak.js: نفس الـ load لفترة أطول، وبنراقب الـ heap والـ p99 بيتغيّروا ولا لأ
import { openLoop, slope } from "./loadgen.js";

const B = "http://localhost:3000";
await openLoop({ url: `${B}/work`, rate: 150, durationMs: 1000 }); // warm-up: الـ JIT والـ connections، مش محسوب
for (const path of ["/work", "/leaky"]) {
  const points = [];
  const t0 = performance.now();
  for (let w = 1; w <= 4; w++) {
    const r = await openLoop({ url: B + path, rate: 150, durationMs: 1000 });
    const { heapMB } = await (await fetch(`${B}/stats`)).json();
    points.push({ t: performance.now() - t0, v: heapMB });
    console.log(`${path.padEnd(7)} window ${w}: p99 ${String(r.p99).padStart(6)}ms | heap ${heapMB.toFixed(1)}MB`);
  }
  const perSec = slope(points);
  console.log(`${path.padEnd(7)} الـ heap بيزيد ${perSec.toFixed(2)}MB في التانية ← ${((perSec * 3600) / 1024).toFixed(1)}GB في الساعة\n`);
}

import { percentile, summarize, closedLoop, openLoop, slope } from "./loadgen.js";

let ok = 0, all = 0;
const check = (name, cond, extra = "") => { all++; if (cond) ok++; console.log(cond ? "✅" : "❌", name, extra); };
const B = "http://localhost:3000";

const lat = Array.from({ length: 100 }, (_, i) => i + 1);
check("percentile: p50 خمسين و p99 تسعة وتسعين", percentile(lat, 50) === 50 && percentile(lat, 99) === 99);
check("percentile: فاضي ← NaN، ومش بيغيّر الأصل", Number.isNaN(percentile([], 50)) && (() => { const a = [3, 1, 2]; percentile(a, 50); return a[0] === 3; })());
const s = summarize(lat, { errors: 25, durationMs: 2500 });
check("summarize: count و errors و rps على الكل", s.count === 100 && s.errors === 25 && s.rps === 50);
check("summarize: p50 و p95 و p99 و max", s.p50 === 50 && s.p95 === 95 && s.p99 === 99 && s.max === 100);
check("summarize: errorRate خمسة وعشرين على مِيّة وخمسة وعشرين", Math.abs(s.errorRate - 0.2) < 1e-9);
check("slope: خط بيطلع اتنين كل تانية ← اتنين", Math.abs(slope([0, 1000, 2000, 3000].map((t) => ({ t, v: 5 + (2 * t) / 1000 }))) - 2) < 1e-9);
check("slope: flat ← صفر، و نقطة واحدة ← صفر", slope([{ t: 0, v: 3 }, { t: 1000, v: 3 }]) === 0 && slope([{ t: 0, v: 9 }]) === 0);
check("slope: noise حوالين خط بينزل ← سالب", slope([{ t: 0, v: 10 }, { t: 1000, v: 9.5 }, { t: 2000, v: 8.7 }, { t: 3000, v: 8.1 }]) < 0);

await fetch(`${B}/stats?reset=1`);
const c = await closedLoop({ url: `${B}/work`, concurrency: 3, durationMs: 600 });
const st = await (await fetch(`${B}/stats`)).json();
check("closedLoop: بيبعت requests ومفيش errors", c.count > 20 && c.errors === 0, `${c.count}`);
check("closedLoop: عمره ما عدّى تلاتة في نفس الوقت", st.maxInFlight >= 2 && st.maxInFlight <= 4, `max in flight ${st.maxInFlight}`);
const o = await openLoop({ url: `${B}/work`, rate: 100, durationMs: 1000 });
check("openLoop: مِيّة في التانية لمدة تانية ← مِيّة request بالضبط", o.count + o.errors === 100, `${o.count}`);
const f = await openLoop({ url: `${B}/fail`, rate: 50, durationMs: 400 });
check("openLoop: five oh three بيتحسب error", f.errors === 20 && f.count === 0 && f.errorRate === 1);
const fc = await closedLoop({ url: `${B}/fail`, concurrency: 2, durationMs: 200 });
check("closedLoop: errors بتتحسب كمان", fc.errors > 0 && fc.count === 0);
const closed = await closedLoop({ url: `${B}/work`, concurrency: 1, durationMs: 2000 });
const open = await openLoop({ url: `${B}/work`, rate: 100, durationMs: 2000 });
check("coordinated omission: open loop شاف الـ pause في الـ p99", open.p99 > 150, `open p99 ${open.p99}ms`);
check("coordinated omission: closed loop مخبّيه", closed.p99 < open.p99 / 2, `closed p99 ${closed.p99}ms`);

console.log(`\n${ok}/${all} نجحوا`);