¿Cómo detectas y solucionas fugas de memoria en Node.js?

Question

Accepted Answer

Una **fuga de memoria** es memoria que ya no se necesita pero nunca se libera, porque algo todavía la referencia. Con el tiempo, el heap del proceso crece hasta que se ralentiza o se cae (out-of-memory). En servidores Node de larga ejecución, las fugas son una preocupación seria de producción.

## Fuentes comunes de fugas

```js
// 1. Cachés sin límite / colecciones globales que solo crecen
const cache = new Map();
app.get("/:id", (req, res) => { cache.set(req.params.id, data); }); // nunca se limpia → crece para siempre

// 2. Listeners de eventos olvidados (agregados repetidamente, nunca removidos)
emitter.on("data", handler); // si se agrega por request y nunca se remueve → se acumula

// 3. Timers olvidados
setInterval(() => {...}, 1000); // nunca se limpia, mantiene referencias vivas

// 4. Closures que capturan objetos grandes por más tiempo del necesario
function outer() {
  const huge = loadBigData();
  return () => huge.length; // mantiene `huge` vivo mientras viva el closure
}
```

El hilo común: una referencia alcanzable (un Map global, un listener activo, un timer en ejecución, un closure) impide que los objetos sean recolectados por el garbage collector aunque ya no sean útiles.

## Detectar fugas

```js
// 1. Observa el crecimiento del heap a lo largo del tiempo — tendencia ascendente sostenida = probable fuga
setInterval(() => {
  const { heapUsed } = process.memoryUsage();
  console.log(`heap: ${(heapUsed / 1e6).toFixed(1)} MB`);
}, 10000);
```

```bash
# 2. Heap snapshots — captura en dos puntos, compara qué creció
node --inspect app.js     # luego usa Chrome DevTools → Memory → heap snapshots
# o las herramientas heapdump / clinic.js
```

El proceso de diagnóstico: confirma que el heap crece de forma sostenida (no es solo fluctuación normal), luego toma **heap snapshots** antes/después de una carga de trabajo y compáralos para encontrar qué tipos de objetos se acumulan (el "retained size" crece).

## Solucionar fugas

```js
// ✅ limita los cachés con TTL/límites de tamaño (LRU)
import { LRUCache } from "lru-cache";
const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 }); // expulsa automáticamente

// ✅ siempre remueve los listeners y limpia los timers
emitter.off("data", handler);
clearInterval(timer);

// ✅ usa WeakMap/WeakSet para metadatos que no deberían mantener objetos vivos
const meta = new WeakMap(); // las entradas se recolectan cuando el objeto clave lo hace
```

Las soluciones reflejan las causas: limita los cachés (LRU con tamaño máximo/TTL), siempre empareja la creación de listeners/timers con su limpieza, y usa `WeakMap`/`WeakSet` para metadatos indexados por objeto que no deberían fijar objetos en memoria.

## Por qué es importante

Las fugas de memoria son especialmente peligrosas en Node porque los servidores son de **larga ejecución** — una fuga lenta que es invisible en desarrollo degrada gradualmente y eventualmente hace caer un proceso de producción (a menudo reiniciándose y perdiendo trabajo en curso).

Conocer las fuentes clásicas (cachés sin límite, listeners/timers no removidos, closures persistentes), cómo detectarlas (monitoreo del heap + comparación de snapshots con DevTools/clinic.js), y las soluciones (cachés LRU acotados, limpieza disciplinada, `WeakMap`) es esencial para operar servicios Node confiables y estables a lo largo del tiempo.