Kaip aptikti ir ištaisyti atminties nuotėkius Node.js?

Question

Accepted Answer

**Atminties nuotėkis** yra atmintis, kurios daugiau nereikia, tačiau ji niekada neatlaisvinama, nes ją vis dar kas nors referenciuoja. Laikui bėgant proceso heap'as auga, kol jis sulėtėja arba sugriūva (out-of-memory). Ilgai veikiančiuose Node serveruose nuotėkiai yra rimtas gamybos uždavinys.

## Dažniausi nuotėkių šaltiniai

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

Bendra tema: pasiekiama referencija (globalinis Map, aktyvus listener'is, veikiantis timer'is, uždarymas) neleidžia objektams būti garbage-collected, nors jie daugiau nebenaudingu.

## Nuotėkių aptikimas

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

Diagnostikos procesas: patvirtinti, kad heap'as tolygiai auga (ne tik normalūs svyravimai), tada imti **heap'o snapshots**'us prieš ir po darbo apkrovą ir palyginti, kad rastume, kurie objektų tipai kaupasi ("retained size" auga).

## Nuotėkių ištaisymas

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

Išaiškinimai atitinka priežastis: riboti cache'ai (LRU su max dydžiu/TTL), visada suderinti listener'io/timer'io sukūrimą su valymu, ir naudoti `WeakMap`/`WeakSet` objektų-pagrindu metaduomenims, kurie neturėtų prisegti objektų atmintyje.

## Kodėl tai svarbu

Atminties nuotėkiai yra ypač pavojingi Node'yje, nes serveriai yra **ilgai veikiantys** — lėtas nuotėkis, kuris kuriant yra nematomas, pamažu pablogina ir galiausiai sugriūva gamybos procesą (dažnai iš naujo paleidžiant ir pralaimint skraidantį darbą).

Žinoti klasikinius šaltinius (neriboti cache'ai, nepasukami listener'iai/timer'iai, lingvistiniai uždarinimai), kaip juos aptikti (heap'o monitoravimas + snapshot'ų palyginimas su DevTools/clinic.js), ir išaiškinimai (riboti LRU cache'ai, disciplinuotas valymas, `WeakMap`) yra būtini patikimų, stabilių Node paslaugų eksploatavimui bėgant laikui.