Hogyan derítheted fel és javíthatod a memóriaszivárgásokat a Node.js-ben?

Question

Accepted Answer

A **memóriaszivárgás** olyan memória, amelyre már nincs szükség, de soha nem szabadul fel, mivel valami továbbra is hivatkozik rá. Idővel a folyamat heapje addig növekszik, amíg le nem lassul vagy össze nem omlik (memória elfogyott). A hosszú ideig futó Node szerverek esetében a szivárgások komoly éles termelési problémát jelentenek.

## Gyakori szivárgásforrások

```js
// 1. Unbounded caches / global collections that only grow
const cache = new Map();
app.get("/:id", (req, res) => { cache.set(req.params.id, data); }); // never cleared → grows forever

// 2. Forgotten event listeners (added repeatedly, never removed)
emitter.on("data", handler); // if added per-request and never removed → accumulates

// 3. Forgotten timers
setInterval(() => {...}, 1000); // never cleared, holds references alive

// 4. Closures capturing large objects longer than needed
function outer() {
  const huge = loadBigData();
  return () => huge.length; // keeps `huge` alive as long as the closure lives
}
```

A közös jellemzője: egy elérhető hivatkozás (egy globális Map, egy aktív listener, egy futó timer, egy closure) megakadályozza az objektumok szemétgyűjtésből való felszabadulását, még akkor is, ha már nincsenek hasznos.

## Szivárgások felderítése

```js
// 1. Watch heap growth over time — steady upward trend = likely leak
setInterval(() => {
  const { heapUsed } = process.memoryUsage();
  console.log(`heap: ${(heapUsed / 1e6).toFixed(1)} MB`);
}, 10000);
```

```bash
# 2. Heap snapshots — capture at two points, compare what grew
node --inspect app.js     # then use Chrome DevTools → Memory → heap snapshots
# or the heapdump / clinic.js tools
```

A diagnosztikai folyamat: erősítsd meg, hogy a heap folyamatosan növekszik (nem csak normális ingadozás), majd készíts **heap pillanatképeket** egy munkateher előtt és után, és hasonlítsd össze, hogy megtaláld, mely objektumtípusok halmozódnak fel (az "retained size" növekszik).

## Szivárgások javítása

```js
// ✅ bound caches with TTL/size limits (LRU)
import { LRUCache } from "lru-cache";
const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 }); // evicts automatically

// ✅ always remove listeners and clear timers
emitter.off("data", handler);
clearInterval(timer);

// ✅ use WeakMap/WeakSet for metadata that shouldn't keep objects alive
const meta = new WeakMap(); // entries are GC'd when the key object is
```

A megoldások tükrözik az okokat: korlátozott gyorsítótárak (LRU max mérettel/TTL-lel), mindig párosítsd a listener/timer létrehozást a tisztítással, és használj `WeakMap`/`WeakSet`-et olyan objektumkulcs-metaadatokhoz, amelyek nem szabad, hogy rögzítsék az objektumokat a memóriában.

## Miért fontos

A memóriaszivárgások különösen veszélyesek a Node-ban, mert a szerverek **hosszú ideig futnak** — egy lassú szivárgás, amely a fejlesztésben láthatatlan, fokozatosan degradálja és végül összeomlik egy éles termelési folyamatot (gyakran újraindítva és munkafolyamatban lévő munkát veszítve).

Az osztályozási szivárgásforrások ismerete (korlátlan gyorsítótárak, eltávolítás nélküli listenrek/timerek, fennmaradó closurek), a felderítés módja (heap monitoring + pillanatkép-összehasonlítás DevTools/clinic.js segítségével) és a megoldások (korlátozott LRU gyorsítótárak, fegyelmezett tisztítás, `WeakMap`) elengedhetetlenek a megbízható, stabil Node szolgáltatások hosszú távú üzemeltetéséhez.