Làm thế nào để phát hiện và sửa memory leak trong Node.js?

Question

Accepted Answer

Một **memory leak** (rò rỉ bộ nhớ) là vùng nhớ không còn cần thiết nhưng không bao giờ được giải phóng, vì vẫn còn thứ gì đó tham chiếu đến nó. Theo thời gian, heap của tiến trình phình to cho đến khi nó chậm lại hoặc crash (hết bộ nhớ). Trong các server Node chạy lâu dài, leak là một mối lo ngại nghiêm trọng ở production.

## Các nguồn leak phổ biến

```js
// 1. Cache không giới hạn / collection toàn cục chỉ phình to lên
const cache = new Map();
app.get("/:id", (req, res) => { cache.set(req.params.id, data); }); // không bao giờ xóa → phình mãi

// 2. Event listener bị quên (thêm lặp đi lặp lại, không bao giờ gỡ)
emitter.on("data", handler); // nếu thêm theo mỗi request và không bao giờ gỡ → tích tụ

// 3. Timer bị quên
setInterval(() => {...}, 1000); // không bao giờ clear, giữ các tham chiếu sống

// 4. Closure bắt giữ các object lớn lâu hơn cần thiết
function outer() {
  const huge = loadBigData();
  return () => huge.length; // giữ `huge` sống chừng nào closure còn sống
}
```

Điểm chung: một tham chiếu còn truy cập được (một Map toàn cục, một listener đang sống, một timer đang chạy, một closure) ngăn các object bị garbage-collect dù chúng không còn hữu ích.

## Phát hiện leak

```js
// 1. Theo dõi heap tăng dần theo thời gian — xu hướng tăng đều = có khả năng leak
setInterval(() => {
  const { heapUsed } = process.memoryUsage();
  console.log(`heap: ${(heapUsed / 1e6).toFixed(1)} MB`);
}, 10000);
```

```bash
# 2. Heap snapshot — chụp tại hai thời điểm, so sánh xem cái gì phình to
node --inspect app.js     # rồi dùng Chrome DevTools → Memory → heap snapshots
# hoặc công cụ heapdump / clinic.js
```

Quy trình chẩn đoán: xác nhận heap tăng đều (không chỉ là dao động bình thường), rồi chụp **heap snapshot** trước/sau một khối lượng công việc và so sánh để tìm xem loại object nào đang tích tụ ("retained size" tăng lên).

## Sửa leak

```js
// ✅ giới hạn cache bằng TTL/giới hạn kích thước (LRU)
import { LRUCache } from "lru-cache";
const cache = new LRUCache({ max: 1000, ttl: 1000 * 60 }); // tự động đẩy ra (evict)

// ✅ luôn gỡ listener và clear timer
emitter.off("data", handler);
clearInterval(timer);

// ✅ dùng WeakMap/WeakSet cho metadata không nên giữ object sống
const meta = new WeakMap(); // các entry bị GC khi object key bị GC
```

Các cách sửa phản chiếu các nguyên nhân: giới hạn cache (LRU với kích thước/TTL tối đa), luôn ghép việc tạo listener/timer với việc dọn dẹp, và dùng `WeakMap`/`WeakSet` cho metadata gắn theo object mà không nên ghim object trong bộ nhớ.

## Tại sao điều này quan trọng

Memory leak đặc biệt nguy hiểm trong Node vì các server **chạy lâu dài** — một leak chậm vô hình trong môi trường development sẽ dần dần làm suy giảm và cuối cùng crash một tiến trình production (thường khởi động lại và mất các công việc đang xử lý).

Biết các nguồn cổ điển (cache không giới hạn, listener/timer không gỡ, closure tồn dư), cách phát hiện chúng (theo dõi heap + so sánh snapshot với DevTools/clinic.js), và các cách sửa (cache LRU có giới hạn, dọn dẹp kỷ luật, `WeakMap`) là điều thiết yếu để vận hành các dịch vụ Node đáng tin cậy, ổn định theo thời gian.