الـ Event Loop Delay والـ ELU: لما Node نفسه يتخنق

// load.js: أربع reports مع بعض، وفي نفس الوقت user تاني بيطلب fast كل عشرين ms
const B = "http://localhost:3000";
const t = async (path) => { const s = performance.now(); const r = await fetch(B + path); await r.text(); return { ms: performance.now() - s, status: r.status }; };
const pct = (a, p) => [...a].sort((x, y) => x - y)[Math.max(0, Math.ceil((p / 100) * a.length) - 1)];

await t("/fast"); // warm-up: أول request دايمًا أبطأ (JIT و connection)
const reports = Array.from({ length: 4 }, () => t("/report?n=200000"));
const fast = [];
for (let i = 0; i < 40; i++) { fast.push(t("/fast")); await new Promise((r) => setTimeout(r, 20)); }
const rs = await Promise.all(reports), fr = await Promise.all(fast), fs = fr.map((x) => x.ms);
console.log(`reports: أبطأ واحد ${Math.max(...rs.map((x) => x.ms)).toFixed(0)}ms`);
console.log(`fast (${fr.filter((x) => x.status === 200).length} من ${fr.length} رجعوا 200): p50 ${pct(fs, 50).toFixed(0)}ms | p99 ${pct(fs, 99).toFixed(0)}ms | max ${Math.max(...fs).toFixed(0)}ms`);
const m = await fetch(B + "/metrics");
console.log("metrics:", m.status, m.status === 200 ? await m.text() : "(مفيش)");

$ node server.js & S=$!; sleep 1; node load.js; kill $S
on 3000
reports: أبطأ واحد 1050ms
fast (40 من 40 رجعوا 200): p50 646ms | p99 1053ms | max 1053ms
metrics: 404 (مفيش)

// loop-monitor.js: نقيس الـ event loop، ونرفض الشغل لما يتخنق، ونقسّم الشغل التقيل
import { monitorEventLoopDelay, performance } from "node:perf_hooks";

export function createMonitor({ intervalMs = 100, resolution = 10 } = {}) {
  const h = monitorEventLoopDelay({ resolution });
  h.enable();
  const state = { lagMs: 0, elu: 0 };
  let expected = performance.now() + intervalMs;
  let last = performance.eventLoopUtilization();
  const timer = setInterval(() => {
    const now = performance.now();
    state.lagMs = Math.max(0, now - expected); // الـ timer اتأخر قد إيه عن ميعاده
    expected = now + intervalMs;
    const cur = performance.eventLoopUtilization();
    state.elu = performance.eventLoopUtilization(cur, last).utilization; // الفرق بين قراءتين
    last = cur;
  }, intervalMs);
  timer.unref(); // ما يمنعش الـ process إنه يقفل
  const ms = (ns) => ns / 1e6, round = (x) => Math.round(x * 10) / 10;
  return {
    lagMs: () => state.lagMs,
    elu: () => state.elu,
    snapshot: () => ({
      lagMs: Math.round(state.lagMs),
      elu: Number(state.elu.toFixed(3)),
      p50: round(ms(h.percentile(50))),
      p99: round(ms(h.percentile(99))),
      max: round(ms(h.max)),
    }),
    reset: () => h.reset(),
    stop: () => { clearInterval(timer); h.disable(); },
  };
}

// load shedding: لو الـ loop متأخر، ارفض بسرعة بدل ما الكل يستنى
export function shed(monitor, { maxLagMs = 100, exempt = ["/health"], retryAfter = 1 } = {}) {
  return (req, res, next) => {
    if (exempt.includes(req.path) || monitor.lagMs() <= maxLagMs) return next();
    res.set("Retry-After", String(retryAfter));
    res.status(503).json({ error: "overloaded", lagMs: Math.round(monitor.lagMs()) });
  };
}

// اشتغل على دفعات، وبين كل دفعة سيب الـ event loop يخدم الباقيين
export async function inChunks(items, fn, size = 1000) {
  const out = [];
  for (let i = 0; i < items.length; i += size) {
    for (let j = i; j < Math.min(i + size, items.length); j++) out.push(fn(items[j], j));
    if (i + size < items.length) await new Promise((r) => setImmediate(r));
  }
  return out;
}

$ node server.js & S=$!; sleep 1; node load.js; kill $S
on 3000
reports: أبطأ واحد 1133ms
fast (40 من 40 رجعوا 200): p50 9ms | p99 108ms | max 108ms
metrics: 200 {"lagMs":3,"elu":1,"p50":10.1,"p99":31.9,"max":43.5}

// server.js: نفس الـ app، بس بيقيس الـ event loop، وبيرفض لما يتخنق، والـ report بقى على دفعات
import express from "express";
import { createHash } from "node:crypto";
import { createMonitor, shed, inChunks } from "./loop-monitor.js";

const app = express();
const monitor = createMonitor({ intervalMs: 100 });
const work = (i) => createHash("sha256").update(String(i)).digest("hex").startsWith("00");

app.get("/health", (req, res) => res.json({ ok: true })); // liveness: قبل الـ shed
app.use(shed(monitor, { maxLagMs: 100 }));
app.get("/fast", (req, res) => res.json({ ok: true }));
app.get("/metrics", (req, res) => res.json(monitor.snapshot()));
app.get("/report", async (req, res) => {
  const n = Number(req.query.n ?? 200000);
  const ids = Array.from({ length: n }, (_, i) => i);
  const hits = (await inChunks(ids, work, 2000)).filter(Boolean).length;
  res.json({ n, hits });
});
// للمعمل بس: بيقفل الـ loop عدد ms، علشان نشوف الـ shed بيشتغل
app.get("/block", (req, res) => {
  const end = Date.now() + Number(req.query.ms ?? 300);
  while (Date.now() < end);
  res.json({ blocked: true });
});

app.listen(3000, () => console.log("on 3000"));

import { createHash } from "node:crypto";
import { createMonitor, shed, inChunks } from "./loop-monitor.js";

let ok = 0, all = 0;
const check = (name, cond, extra = "") => { all++; if (cond) ok++; console.log(cond ? "✅" : "❌", name, extra); };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const block = (ms) => { const end = Date.now() + ms; while (Date.now() < end); };
const B = "http://localhost:3000";

const m = createMonitor({ intervalMs: 50 });
await sleep(200);
const s0 = m.snapshot();
check("snapshot فيه lagMs و elu و p50 و p99 و max", ["lagMs", "elu", "p50", "p99", "max"].every((k) => typeof s0[k] === "number"));
check("وهو فاضي: lag صغير و elu صغير", m.lagMs() < 30 && m.elu() < 0.3, `lag ${m.lagMs().toFixed(1)} elu ${m.elu().toFixed(2)}`);
block(300);
await sleep(10);
check("بعد block تلتمية ms ← lagMs فوق ميتين", m.lagMs() > 200, `${m.lagMs().toFixed(0)}ms`);
check("و elu فوق نص", m.elu() > 0.5, m.elu().toFixed(2));
check("و max في الـ histogram فوق ميتين وخمسين", m.snapshot().max > 250, `${m.snapshot().max}ms`);
await sleep(200);
check("بعد ما ارتاح ← lag رجع صغير", m.lagMs() < 30, `${m.lagMs().toFixed(1)}ms`);
m.reset();
check("reset بيصفّر الـ histogram", m.snapshot().max < 250);
m.stop();

const fakeRes = () => { const r = { headers: {}, code: 200, body: null }; r.set = (k, v) => ((r.headers[k] = v), r); r.status = (c) => ((r.code = c), r); r.json = (b) => ((r.body = b), r); return r; };
const runShed = (lag, path, opts) => { let nextCalled = false; const res = fakeRes(); shed({ lagMs: () => lag }, opts)({ path }, res, () => (nextCalled = true)); return { nextCalled, res }; };
const a = runShed(500, "/fast");
check("shed: lag خمسمية ← 503", !a.nextCalled && a.res.code === 503);
check("shed: فيه Retry-After و error overloaded", a.res.headers["Retry-After"] === "1" && a.res.body?.error === "overloaded");
check("shed: lag خمسين ← next", runShed(50, "/fast").nextCalled);
check("shed: /health معفي حتى لو lag عالي", runShed(500, "/health").nextCalled);
check("shed: maxLagMs و exempt بيتغيّروا", runShed(50, "/x", { maxLagMs: 20 }).res.code === 503 && runShed(500, "/x", { exempt: ["/x"] }).nextCalled);

const nums = Array.from({ length: 10000 }, (_, i) => i);
check("inChunks: نفس النتيجة ونفس الترتيب", (await inChunks(nums, (x) => x * 2, 1000)).every((v, i) => v === i * 2));
check("inChunks: الـ index بيتبعت تاني parameter", (await inChunks(["a", "b"], (x, i) => x + i)).join() === "a0,b1");
check("inChunks: array فاضية ← فاضية", (await inChunks([], (x) => x)).length === 0);
let ran = false, seen = false;
setImmediate(() => (ran = true));
await inChunks(nums, (x) => { if (x === 9999) seen = ran; return x; }, 1000);
check("inChunks بيسيب الـ event loop يشتغل بين الدفعات", seen === true);

const get = async (p) => { const s = performance.now(); const r = await fetch(B + p); const body = await r.json().catch(() => null); return { status: r.status, body, ms: performance.now() - s, retry: r.headers.get("retry-after") }; };
await ge
…