الـ Memory والـ GC والـ Leaks: الـ process اللي بيكبر لحد ما يقع

// leak.js: خمسين user، كل واحد بيطلب الـ report بتاعه، وكل مرة الـ t جديد
const B = "http://localhost:3000";
const get = async (p) => (await fetch(B + p)).json();
const name = process.argv[2] ?? "run";
const show = async (i) => { const m = await get("/debug/memory"); console.log(`${String(i).padStart(5)} request ← heap ${m.heapUsedMB}MB | cache ${m.cache} | listeners ${m.listeners}`); };

await get(`/debug/snapshot?name=${name}-before`);
await show(0);
for (let i = 1; i <= 2000; i++) {
  await get(`/report?user=u${i % 50}&t=${i}`);
  if (i % 500 === 0) await show(i);
}
await get(`/debug/snapshot?name=${name}-after`);
console.log(`snapshots: snaps/${name}-before و snaps/${name}-after`);

$ mkdir -p snaps; node --expose-gc server.js & S=$!; sleep 1; node leak.js naive; kill $S
on 3000
    0 request ← heap 6.6MB | cache 0 | listeners 0
warning: MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 flush listeners added t
  500 request ← heap 10.5MB | cache 500 | listeners 500
 1000 request ← heap 13.8MB | cache 1000 | listeners 1000
 1500 request ← heap 17.1MB | cache 1500 | listeners 1500
 2000 request ← heap 20.3MB | cache 2000 | listeners 2000
snapshots: snaps/naive-before و snaps/naive-after

// mem.js: cache بحد، وقراية heap snapshots ومقارنتهم

// LRU: Map بيحفظ ترتيب الإضافة، فأول key فيه هو أقدم واحد اتلمس
export function createLRU({ max = 1000, ttlMs = Infinity, now = Date.now } = {}) {
  const m = new Map();
  const fresh = (e) => now() - e.at < ttlMs;
  return {
    get(k) {
      const e = m.get(k);
      if (!e) return undefined;
      if (!fresh(e)) { m.delete(k); return undefined; } // انتهى
      m.delete(k); m.set(k, e); // اتلمس ← يروح الآخر
      return e.v;
    },
    set(k, v) {
      m.delete(k);
      m.set(k, { v, at: now() });
      while (m.size > max) m.delete(m.keys().next().value); // شيل الأقدم
      return this;
    },
    has(k) { return this.get(k) !== undefined; },
    get size() { return m.size; },
  };
}

// heap snapshot: nodes array واحدة طويلة، كل node عدد fields بالترتيب اللي في meta.node_fields
const KINDS = new Set(["object", "closure", "array", "string", "regexp"]);
export function heapCounts(snap) {
  const meta = snap.snapshot.meta, F = meta.node_fields, types = meta.node_types[0];
  const step = F.length, iType = F.indexOf("type"), iName = F.indexOf("name"), iSize = F.indexOf("self_size");
  const out = new Map();
  for (let i = 0; i < snap.nodes.length; i += step) {
    const type = types[snap.nodes[i + iType]];
    if (!KINDS.has(type)) continue;
    // الـ object اسمه الـ constructor، والـ closure اسمه اسم الـ function، والباقي بنوعه
    const name = type === "object" || type === "closure" ? `${snap.strings[snap.nodes[i + iName]] || "(anonymous)"}${type === "closure" ? "()" : ""}` : `(${type})`;
    const r = out.get(name) ?? { count: 0, size: 0 };
    r.count++; r.size += snap.nodes[i + iSize];
    out.set(name, r);
  }
  return out;
}

export function diffHeaps(before, after, { n = 5 } = {}) {
  const a = heapCounts(before), b = heapCounts(after);
  return [...b].map(([name, r]) => {
    const old = a.get(name) ?? { count: 0, size: 0 };
    return { name, countDelta: r.count - old.count, sizeDelta: r.size - old.size };
  }).filter((r) => r.countDelta > 0).sort((x, y) => y.sizeDelta - x.sizeDelta).slice(0, n);
}

$ node diff.js naive
أكتر حاجات زادت في naive:
  + 82076 نسخة  +  2925KB  (string)
  + 28015 نسخة  +  2681KB  (array)
  + 54022 نسخة  +  2407KB  Object
  + 26010 نسخة  +   813KB  Array
  +  2000 نسخة  +   781KB  ServerResponse
  +  8002 نسخة  +   641KB  system / Context

زادوا 2000 بالضبط، يعني واحد لكل request: ServerResponse، IncomingMessage، Url، next()، trimPrefix()، onFlush()، Report

// server.js: نفس الـ app، بس الـ cache ليه حد، والـ listener واحد بس
import express from "express";
import { EventEmitter } from "node:events";
import { writeHeapSnapshot } from "node:v8";
import { createLRU } from "./mem.js";

class Report {
  constructor(user, t) {
    this.user = user;
    this.t = t;
    this.rows = Array.from({ length: 20 }, (_, i) => ({ i, v: i * 3.5, label: `row-${user}-${i}` }));
  }
}

const app = express();
// warnings بتاعة Node بتروح للـ logs زي أي حاجة تانية، علشان ما تضيعش
process.on("warning", (w) => console.log(`warning: ${w.name}: ${w.message.slice(0, 70)}`));
const bus = new EventEmitter();
const cache = createLRU({ max: 500, ttlMs: 60_000 }); // أي cache لازم يبقى ليه حد
let lastUrl = null;
bus.on("flush", () => console.log("flush", lastUrl)); // listener واحد، مرة واحدة في الـ startup

app.get("/report", (req, res) => {
  const key = `${req.query.user}:${req.query.t}`;
  if (!cache.has(key)) cache.set(key, new Report(req.query.user, req.query.t));
  lastUrl = req.url;
  res.json({ rows: cache.get(key).rows.length });
});
// للمعمل بس: في production الـ routes دي ورا auth، أو على port داخلي
app.get("/debug/memory", (req, res) => {
  globalThis.gc?.(); // محتاج node --expose-gc: نقيس اللي فاضل بعد الـ GC بس
  const m = process.memoryUsage();
  const mb = (x) => Math.round((x / 1048576) * 10) / 10;
  res.json({ heapUsedMB: mb(m.heapUsed), rssMB: mb(m.rss), cache: cache.size, listeners: bus.listenerCount("flush") });
});
app.get("/debug/snapshot", (req, res) => {
  globalThis.gc?.();
  res.json({ file: writeHeapSnapshot(`snaps/${req.query.name}.heapsnapshot`) });
});
app.listen(3000, () => console.log("on 3000"));

// diff.js: إيه اللي زاد بين الـ snapshot الأولاني والأخراني؟
import { readFileSync } from "node:fs";
import { diffHeaps } from "./mem.js";

const name = process.argv[2] ?? "naive";
const load = (f) => JSON.parse(readFileSync(`snaps/${name}-${f}.heapsnapshot`, "utf8"));
console.log(`أكتر حاجات زادت في ${name}:`);
for (const r of diffHeaps(load("before"), load("after"), { n: 6 }))
  console.log(`  +${String(r.countDelta).padStart(6)} نسخة  +${(r.sizeDelta / 1024).toFixed(0).padStart(6)}KB  ${r.name}`);

// الـ trick: دوّر على الحاجات اللي زادت بعدد الـ requests بالضبط
const per = Number(process.argv[3] ?? 2000);
const exact = diffHeaps(load("before"), load("after"), { n: 1000 }).filter((r) => r.countDelta === per);
console.log(`\nزادوا ${per} بالضبط، يعني واحد لكل request: ${exact.map((r) => r.name).join("، ") || "ولا حاجة"}`);

import { writeHeapSnapshot } from "node:v8";
import { mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { createLRU, heapCounts, diffHeaps } from "./mem.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 c = createLRU({ max: 3 });
c.set("a", 1).set("b", 2).set("c", 3);
check("LRU: get و size", c.get("a") === 1 && c.size === 3);
c.set("d", 4);
check("LRU: الرابع بيشيل الأقدم (b، لأن a اتلمس)", !c.has("b") && c.has("a") && c.has("c") && c.has("d") && c.size === 3);
c.set("c", 30);
c.set("e", 5);
check("LRU: set لـ key موجود بيحدّثه ويرجّعه الآخر", c.get("c") === 30 && !c.has("a"));
check("LRU: key مش موجود ← undefined", c.get("zzz") === undefined);
let t = 0;
const tl = createLRU({ max: 10, ttlMs: 100, now: () => t });
tl.set("x", 1);
t = 99;
check("TTL: قبل ما يخلص ← موجود", tl.get("x") === 1);
t = 100;
check("TTL: بعد ما يخلص ← undefined ومتشال", tl.get("x") === undefined && tl.size === 0);
const big = createLRU({ max: 100 });
for (let i = 0; i < 10000; i++) big.set(i, i);
check("LRU: عشرة آلاف set ← مية بس", big.size === 100 && big.has(9999) && !big.has(0));

const fake = (nodes) => ({
  snapshot: { meta: { node_fields: ["type", "name", "id", "self_size", "edge_count"], node_types: [["hidden", "array", "string", "object", "code", "closure"]] } },
  strings: ["", "User", "onClick", "x"],
  nodes: nodes.flatMap(([type, name, size]) => [type, name, 0, size, 0]),
});
const s1 = fake([[3, 1, 40], [3, 1, 40], [5, 2, 32], [2, 3, 16], [4, 3, 100], [0, 3, 8], [3, 0, 24]]);
const hc = heapCounts(s1);
check("heapCounts: User اتنين بتمانين byte", hc.get("User")?.count === 2 && hc.get("User")?.size === 80);
check("heapCounts: الـ closure باسم الـ function و ()", hc.get("onClick()")?.count === 1);
check("heapCounts: string ← (string)، و object من غير اسم ← (anonymous)", hc.get("(string)")?.count === 1 && hc.get("(anonymous)")?.count === 1);
check("heapCounts: code و hidden مش محسوبين", hc.size === 4);
const s2 = fake([[3, 1, 40], [3, 1, 40], [3, 1, 40], [5, 2, 32], [5, 2, 32], [5, 2, 32], [2, 3, 16]]);
const d = diffHeaps(s1, s2);
check("diffHeaps: onClick زاد اتنين، User زاد واحد", d.find((r) => r.name === "onClick()")?.countDelta === 2 && d.find((r) => r.name === "User")?.countDelta === 1);
check("diffHeaps: مترتب بالـ size، واللي ما زادش مش موجود", d[0].name === "onClick()" && !d.some((r) => r.name === "(string)" || r.name === "(anonymous)"));
check("diffHeaps: n", diffHeaps(s1, s2, { n: 1 }).length === 1);

class Leaky { constructor(i) { this.i = i; } }
const dir = mkdtempSync(`${tmpdir()}/heap-`);
const snap = (n) => JSON.parse(readFileSync(writeHeapSnapshot(`${dir}/${n}.heapsnapshot`), "utf8"));
const before = snap("a");
globalThis.keep = Array.from({ length: 3000 }, (_, i) => new Leaky(i));
const after = snap("b");
rmSync(dir, { recursive: true });
const leaky = diffHeaps(before, 
…