Kako detektirati i ispraviti curenja memorije u Node.js?

Question

Accepted Answer

**Curenje memorije** je memorija koja više nije potrebna, ali nikad nije oslobođena jer je nešto i dalje referenciira. Tijekom vremena heap procesa raste dok se ne usporimo ili ne padnemo (nedostatak memorije). U dugotrajnim Node serverima, curenja su ozbiljna proizvodna zabrinutost.

## Česti izvori curenja

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

Zajedničko svojstvo: dostižna referenca (globalna Map, aktivni listener, pokrenuti timer, closure) sprječava brisanje objekata zabirom čak i ako više nisu korisni.

## Detekcija curenja

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

Dijagnostički proces: potvrdite da heap raste stalno (ne samo normalne fluktuacije), zatim napravite **heap snimke** prije/poslije radnog opterećenja i usporedite kako biste pronašli koje vrste objekata se akumuliraju ("retained size" raste).

## Ispravljanje curenja

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

Ispravke ogledavaju uzroke: ograničene memorijske keše (LRU s maksimalnom veličinom/TTL), uvijek uparite stvaranje listener/timer s čišćenjem, i koristite `WeakMap`/`WeakSet` za metadata na osnovi objekata koji ne bi trebali držati objekte u memoriji.

## Zašto je to važno

Curenja memorije posebno su opasna u Node-u jer su serveri **dugotrajna** — spora curenja koja je nevidljiva tijekom razvoja polako degradira i na kraju ruši proizvodni proces (često se restartira i gubi rad u tijeku).

Znanje klasičnih izvora (neograničene memorijske keše, uklonjeni listeneri/tajmeri, dugoročni closures), kako ih detektirati (heap monitoring + usporedba snimki s DevTools/clinic.js), i ispravke (ograničene LRU keše, disciplinirano čišćenje, `WeakMap`) je bitno za rad pouzdanih, stabilnih Node usluga tijekom vremena.