Piye carane ndeteksi lan ndandani memory leaks ing Node.js?

Question

Accepted Answer

A **memory leak** iku memory sing wis ora dibutuhake nanging ora tau dibebasake, amarga isih ana sing referensi. Sajroning wektu, heap proses tansah jiyar nganti nglambat utawa crush (out-of-memory). Ing server Node sing dawa-dawa, leaks iku kasunyatan produksi sing serius.

## Sumber leak sing umum

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

Jalaran umum: referensi sing bisa dijangkau (global Map, listener sing isih urip, timer sing mlaku, closure) nyegah obyek supaya ora dibersihke dening garbage collector sanajan luwih ora migunani.

## Ndeteksi leaks

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

Proses diagnostik: pastikake heap tansah jiyar (dudu mung fluktuasi normal), banjur takno **heap snapshots** sadurunge/sawise workload lan bandingake kanggo golek jinis obyek endi sing numpuk ("retained size" jiyar).

## Ndandani leaks

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

Ndandani spesial saka sebabe: cache sing kebatesan (LRU kanthi ukuran maks/TTL), lakune pasang listener/timer cleanup karo, lan guna `WeakMap`/`WeakSet` kanggo metadata kunci-obyek sing ora kudu ngepin obyek ing memory.

## Apa wigatinya

Memory leaks luwih mbebayani ing Node amarga server iku **dawa-dawa** — leak alon sing ora kasat mata ing development bakal lumrah nglambat lan pungkasan crush proses produksi (asring restart lan cilaka pekerjaan sing lagi mlaku).

Ngerti sumber klasik (cache ora kebatesan, listener/timer sing ora dibuwas, closure sing isih ana), carane ndeteksi (heap monitoring + perbandingan snapshot karo DevTools/clinic.js), lan ndandani (bounded LRU caches, cleanup disiplin, `WeakMap`) iku penting kanggo ngopèrasi layanan Node sing stabil lan ajeg sajroning wektu.