Hvordan oppdager og fikser du minnelekkasjer i Node.js?

Question

Accepted Answer

En **minnelekkasje** er minne som ikke lenger trengs, men som aldri frigjøres fordi noe fortsatt refererer til det. Over tid vokser prosessens heap til den bremser eller krasjer (out-of-memory). I langvarige Node-servere er lekkasjer en alvorlig bekymring for produksjon.

## Vanlige lekkasjekilder

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

Felles tema: en tilgjengelig referanse (et globalt Map, en aktiv lytter, en kjørende timer, en lukket scope) holder objekt fra å bli søppelsamlet selv om de ikke lenger er nyttige.

## Oppdage lekkasjer

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

Diagnostiseringsprosessen: bekreft at heapen vokser jevnt (ikke bare normal fluktasjon), ta deretter **heap-øyeblikksbilder** før/etter en arbeidsbelastning og sammenlign for å finne hvilke objekttyper som akkumuleres ("retained size" vokser).

## Fikse lekkasjer

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

Fiksene speiler årsakene: begrenset bufring (LRU med maksimumstørrelse/TTL), alltid parkoble lytter-/timer-opprettelse med opprydding, og bruk `WeakMap`/`WeakSet` for objekt-nøkklet metadata som ikke bør holde objekter i minnet.

## Hvorfor det er viktig

MinneLekkasjer er spesielt farlige i Node fordi servere **kjøres lenge** — en langsom lekkasje som er usynlig i utvikling forverrer gradvis og krasjer til slutt en produksjonsprosess (ofte startes på nytt og mister arbeid som pågår).

Kjennskap til klassiske kilder (ubegrenset bufring, fjernet lystre/timere, langvarige lukkede scoper), hvordan man oppdager dem (heap-overvåking + øyeblikksbildesammenligning med DevTools/clinic.js), og fiksene (begrenset LRU-bufring, disiplinert opprydding, `WeakMap`) er essensielt for å drifte pålitelige, stabile Node-tjenester over tid.