Bagaimana cara mendeteksi dan memperbaiki memory leak di Node.js?

Question

Accepted Answer

A **memory leak** adalah memori yang tidak lagi dibutuhkan tetapi tidak pernah dibebaskan, karena sesuatu masih mereferensikannya. Seiring waktu, heap proses tumbuh hingga melambat atau crash (out-of-memory). Di server Node yang berjalan lama, leak adalah masalah produksi yang serius.

## Sumber leak 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
}
```

Benang umum: referensi yang dapat dijangkau (Map global, listener hidup, timer yang berjalan, closure) mencegah objek dari garbage collection meskipun mereka tidak lagi berguna.

## Mendeteksi leak

```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: konfirmasi heap tumbuh secara konsisten (bukan hanya fluktuasi normal), kemudian ambil **heap snapshots** sebelum/sesudah beban kerja dan bandingkan untuk menemukan jenis objek mana yang menumpuk ("retained size" bertambah).

## Memperbaiki leak

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

Perbaikan mencerminkan penyebabnya: cache terikat (LRU dengan ukuran/TTL maksimal), selalu pasangkan pembuatan listener/timer dengan pembersihan, dan gunakan `WeakMap`/`WeakSet` untuk metadata dengan kunci objek yang tidak seharusnya menahan objek dalam memori.

## Mengapa ini penting

Memory leak sangat berbahaya di Node karena server adalah **long-running** — leak lambat yang tidak terlihat dalam development secara bertahap menurunkan dan akhirnya crash proses produksi (sering kali restart dan kehilangan pekerjaan yang sedang berlangsung).

Mengetahui sumber klasik (cache tidak terbatas, listener/timer yang tidak dihapus, closure yang tersisa), cara mendeteksinya (heap monitoring + perbandingan snapshot dengan DevTools/clinic.js), dan perbaikannya (cache LRU terbatas, pembersihan disiplin, `WeakMap`) sangat penting untuk mengoperasikan layanan Node yang andal dan stabil seiring waktu.