How do you detect and fix memory leaks in Node.js?

Question

Accepted Answer

A **memory leak** is memory that's no longer needed but never freed, because something still references it. Over time the process's heap grows until it slows down or crashes (out-of-memory). In long-running Node servers, leaks are a serious production concern.

## Common leak sources

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

The common thread: a reachable reference (a global Map, a live listener, a running timer, a closure) keeps objects from being garbage-collected even though they're no longer useful.

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

The diagnostic process: confirm the heap grows steadily (not just normal fluctuation), then take **heap snapshots** before/after a workload and compare to find which object types are accumulating ("retained size" growing).

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

The fixes mirror the causes: bound caches (LRU with max size/TTL), always pair listener/timer creation with cleanup, and use `WeakMap`/`WeakSet` for object-keyed metadata that shouldn't pin objects in memory.

## Why it matters

Memory leaks are especially dangerous in Node because servers are **long-running** — a slow leak that's invisible in development gradually degrades and eventually crashes a production process (often restarting and losing in-flight work).

Knowing the classic sources (unbounded caches, un-removed listeners/timers, lingering closures), how to detect them (heap monitoring + snapshot comparison with DevTools/clinic.js), and the fixes (bounded LRU caches, disciplined cleanup, `WeakMap`) is essential for operating reliable, stable Node services over time.