Hoe detecteer en fix je geheugenleaks in Node.js?

Question

Accepted Answer

Een **memory leak** is geheugen dat niet langer nodig is maar nooit vrijgegeven wordt, omdat iets er nog naar verwijst. Na verloop van tijd groeit de heap van het proces totdat het traag wordt of crasht (out-of-memory). In langlopende Node-servers zijn leaks een ernstig productieprobleem.

## Veel voorkomende bronnen van leaks

```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
}
```

De gemeenschappelijke factor: een bereikbare verwijzing (een globale Map, een actieve listener, een lopende timer, een closure) voorkomt dat objecten door de garbage collector worden vrijgegeven, ook al zijn ze niet langer nuttig.

## Leaks detecteren

```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
```

Het diagnostische proces: bevestig dat de heap gestaag groeit (niet alleen normale fluctuatie), maak vervolgens **heap snapshots** voor/na een workload en vergelijk om erachter te komen welke objecttypen zich ophopen ("retained size" groeit).

## Leaks oplossen

```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
```

De oplossingen spiegelen de oorzaken: bounded caches (LRU met max size/TTL), zorg altijd dat listener/timer-creatie met cleanup gepaard gaat, en gebruik `WeakMap`/`WeakSet` voor object-gesleutelde metadata die objecten niet in het geheugen moet vasthouden.

## Waarom het belangrijk is

Geheugenleaks zijn bijzonder gevaarlijk in Node omdat servers **langlopend** zijn — een langzaam leak dat onzichtbaar is in development, degradeert geleidelijk en crasht uiteindelijk een productieproces (wat zich vaak opnieuw opstart en lopend werk verliest).

Het kennen van de klassieke bronnen (unbounded caches, verwijderde listeners/timers, overblijvende closures), hoe deze te detecteren (heap monitoring + snapshot-vergelijking met DevTools/clinic.js), en de oplossingen (bounded LRU caches, disciplineerde cleanup, `WeakMap`) is essentieel voor het beheren van betrouwbare, stabiele Node-services over tijd.