Comment détecter et corriger les fuites mémoire dans Node.js ?

Question

Accepted Answer

Une **fuite mémoire** est de la mémoire qui n'est plus nécessaire mais jamais libérée, parce que quelque chose la référence encore. Au fil du temps, le heap du processus augmente jusqu'à ce qu'il ralentisse ou plante (dépassement mémoire). Dans les serveurs Node de longue durée, les fuites sont une préoccupation sérieuse en production.

## Sources courantes de fuites

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

Le fil conducteur : une référence accessible (une Map globale, un listener actif, un timer en cours, une closure) empêche les objets d'être garbage-collected même s'ils ne sont plus utiles.

## Détecter les fuites

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

Le processus de diagnostic : confirmer que le heap augmente de manière régulière (pas seulement une fluctuation normale), puis prendre des **snapshots du heap** avant/après une charge de travail et comparer pour trouver quels types d'objets s'accumulent (« retained size » qui augmente).

## Corriger les fuites

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

Les corrections reflètent les causes : caches limitées (LRU avec taille max/TTL), toujours associer la création listener/timer avec un nettoyage, et utiliser `WeakMap`/`WeakSet` pour les métadonnées indexées par objet qui ne devraient pas épingler les objets en mémoire.

## Pourquoi c'est important

Les fuites mémoire sont particulièrement dangereuses dans Node parce que les serveurs sont **de longue durée** — une fuite lente qui est invisible en développement dégrade graduellement et finit par faire planter un processus en production (souvent en redémarrant et en perdant le travail en cours).

Connaître les sources classiques (caches non-limitées, listeners/timers non-supprimés, closures persistantes), comment les détecter (monitoring du heap + comparaison de snapshots avec DevTools/clinic.js), et les corrections (caches LRU limitées, nettoyage discipliné, `WeakMap`) est essentiel pour exploiter des services Node fiables et stables au fil du temps.