Kako zaznati in popraviti puščanje pomnilnika v Node.js?

Question

Accepted Answer

A **memory leak** (puščanje pomnilnika) je pomnilnik, ki ni več potreben, vendar se nikoli ne sprosti, ker ga še vedno nešto referenciira. Sčasoma se heap procesa povečuje, dokler se ne upočasni ali ne sesuje (out-of-memory). V dolgoročno delujoči servrih Node so puščanja resna težava v produkciji.

## Pogoste viri puščanj

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

Splošna napetost: dosegljiva referenca (globalna Map, aktiven listener, tekoči timer, closure) preprečuje, da bi se objekti zbrisali z garbage collection, čeprav niso več koristni.

## Zaznavanje puščanj

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

Proces diagnostike: potrdite, da se heap povečuje stalno (ne samo normalne nihaje), nato naredite **heap snapshots** pred/po delovno obremenitvijo in jih primerjajte, da poiščete katere vrste objektov se kopičijo (rastoča "retained size").

## Popravek puščanj

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

Popravki odražajo vzroke: omejeni cachei (LRU z največjo velikostjo/TTL), vedno seznanite ustvarjanje listener/timer s čištenjem, in uporabite `WeakMap`/`WeakSet` za metapodatke s ključem-objektom, ki ne bi trebali obdržati objekte v pomnilniku.

## Zakaj je to važno

Puščanja pomnilnika so posebej nevarna v Node, ker so strežniki **dolgoročno delujejo** — počasno puščanje, ki je v razvoju nevidno, postopoma poslabša in na koncu sesuje produkcijski proces (pogosto se znova zažene in izgubi delo v teku).

Ppoznavanje klasičnih virov (neomejeni cachei, odstranjeni listeners/timers, lingvečni closures), kako jih zaznati (spremljanje heapu + primerjava snapshots z DevTools/clinic.js) in popravkov (omejeni LRU cachei, disciplinirano čiščenje, `WeakMap`) je bistveno za delovanje zanesljivih, stabilnih Node storitev skozi čas.