Como você detecta e corrige vazamentos de memória em Node.js?

Question

Accepted Answer

A **memory leak** (vazamento de memória) é a memória que não é mais necessária mas nunca é liberada, porque algo ainda a referencia. Com o tempo, o heap do processo cresce até desacelerar ou falhar (out-of-memory). Em servidores Node de longa duração, vazamentos são uma preocupação séria de produção.

## Fontes comuns de vazamentos

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

O fio condutor: uma referência alcançável (um Map global, um listener ativo, um timer em execução, um closure) impede que objetos sejam coletados pelo garbage collection, mesmo que não sejam mais úteis.

## Detectando vazamentos

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

O processo de diagnóstico: confirme que o heap cresce constantemente (não apenas flutuação normal), depois tire **heap snapshots** antes/depois de uma carga de trabalho e compare para encontrar quais tipos de objeto estão acumulando ("retained size" crescendo).

## Corrigindo vazamentos

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

As correções espelham as causas: caches limitados (LRU com tamanho máximo/TTL), sempre associe a criação de listener/timer com limpeza, e use `WeakMap`/`WeakSet` para metadados com chave de objeto que não devem manter objetos na memória.

## Por que isso importa

Vazamentos de memória são especialmente perigosos em Node porque servidores são **de longa duração** — um vazamento lento que é invisível no desenvolvimento degrada gradualmente e eventualmente falha um processo de produção (frequentemente reiniciando e perdendo trabalho em andamento).

Conhecer as fontes clássicas (caches ilimitados, listeners/timers não removidos, closures pendentes), como detectá-las (monitoramento de heap + comparação de snapshots com DevTools/clinic.js) e as correções (caches LRU limitados, limpeza disciplinada, `WeakMap`) é essencial para operar serviços Node confiáveis e estáveis ao longo do tempo.