Kuinka havaitset ja korjaat muistivuodot Node.js:ssä?

Question

Accepted Answer

**Muistivuoto** on muistia, jota ei enää tarvita mutta jota ei koskaan vapauteta, koska jokin viittaa siihen edelleen. Ajan myötä prosessin heap kasvaa, kunnes se hidastuu tai kaatuu (muisti loppui). Pitkäkestoisilla Node-palvelimilla vuodot ovat vakava tuotantoproblem.

## Yleiset vuotojen lähteet

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

Yhteinen säie: saavutettavissa oleva viittaus (globaali Map, aktiivinen listener, käynnissä oleva timer, sulkeminen) pitää objekteja roskienkeräyksestä, vaikka ne eivät ole enää hyödyllisiä.

## Vuotojen havaitseminen

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

Diagnostiikkaprosessi: varmista, että heap kasvaa tasaisesti (ei vain normaalia vaihtelua), ota sitten **heap-tilannekuvat** ennen/jälkeen kuorman ja vertaa löytääksesi mitkä objektitypit keräävät ("retained size" kasvaa).

## Vuotojen korjaaminen

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

Korjaukset heijastavat syitä: rajatut välimuistit (LRU maksimikoko/TTL), yhdistä aina listener/timer-luonti siivousten kanssa ja käytä `WeakMap`/`WeakSet` objekti-avainten metatiedoille, jotka eivät saa kiinnittää objekteja muistiin.

## Miksi sillä on merkitystä

Muistivuodot ovat erityisen vaarallisia Node:ssa, koska palvelimet ovat **pitkäkestoisia** — hidas vuoto, joka on näkymätön kehityksessä, heikkenee vähitellen ja lopulta kaataa tuotantoprosessin (usein uudelleenkäynnistys ja meneillään olevan työn menetys).

Klassisten lähteiden tunteminen (rajoittomat välimuistit, poistetut listenerit/timerit, jäljellä olevat sulkemiset), niiden havaitseminen (heap-seuranta + tilannekuvien vertailu DevTools/clinic.js:n kanssa) ja korjaukset (rajatut LRU-välimuistit, kurinalaisuuden siivous, `WeakMap`) on välttämätöntä luotettavien, vakaan Node-palveluiden käyttämiselle ajan mittaan.