Cum detectezi și repari scurgerile de memorie în Node.js?

Question

Accepted Answer

A **memory leak** (scurgere de memorie) este memoria care nu mai este necesară dar nu este niciodată eliberată, deoarece ceva o mai referențiază. În timp, heap-ul procesului crește până se încetinește sau se blochează (out-of-memory). În serverele Node cu funcționare lungă, scurgerile sunt o problemă serioasă de producție.

## Surse comune de scurgeri

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

Firul conductor: o referință accesibilă (o Map globală, un listener activ, un timer în execuție, o closure) împiedică ca obiectele să fie colectate de garbage collection, chiar dacă nu mai sunt utile.

## Detectarea scurgerilor

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

Procesul de diagnostic: confirmă că heap-ul crește constant (nu doar fluctuații normale), apoi ia **heap snapshots** înainte/după o sarcină de lucru și compară pentru a găsi ce tipuri de obiecte se acumulează ("retained size" în creștere).

## Repararea scurgerilor

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

Reparațiile reflectă cauzele: cache-uri delimitate (LRU cu dimensiune maximă/TTL), asociază întotdeauna crearea listener/timer cu curățare, și folosește `WeakMap`/`WeakSet` pentru metadate cu cheie de obiect care nu ar trebui să păstreze obiecte în memorie.

## De ce este important

Scurgerile de memorie sunt deosebit de periculoase în Node deoarece serverele sunt **cu funcționare lungă** — o scurgere lentă care este invizibilă în dezvoltare se degradează gradual și în cele din urmă defectează un proces de producție (adesea repornind și pierând munca în curs).

Cunoașterea surselor clasice (cache-uri nelimitate, listeneri/timeri neîndepărtați, closure-uri rămase), cum să le detectezi (monitorizarea heap-ului + compararea snapshot-urilor cu DevTools/clinic.js) și reparațiile (cache-uri LRU delimitate, curățare disciplinată, `WeakMap`) este esențială pentru operarea serviciilor Node fiabile și stabile în timp.