คุณตรวจจับและแก้ไข memory leak ใน Node.js อย่างไร?

Question

Accepted Answer

**Memory leak** คือหน่วยความจำที่ไม่จำเป็นแล้วแต่ไม่เคยถูกคืน เพราะมีบางสิ่งยังอ้างอิงถึงมันอยู่ เมื่อเวลาผ่านไป heap ของ process จะโตขึ้นเรื่อย ๆ จนช้าลงหรือ crash (out-of-memory) ในเซิร์ฟเวอร์ Node ที่ทำงานต่อเนื่องเป็นเวลานาน leak ถือเป็นปัญหา production ที่ร้ายแรง

## แหล่งที่มาของ leak ที่พบบ่อย

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

จุดร่วมคือ การอ้างอิงที่ยังเข้าถึงได้ (global Map, listener ที่ยังทำงานอยู่, timer ที่กำลังรัน, closure) ทำให้ object ไม่ถูก garbage-collected แม้จะไม่มีประโยชน์อีกต่อไปแล้ว

## การตรวจจับ 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
```

กระบวนการวินิจฉัยคือ ยืนยันก่อนว่า heap โตขึ้นอย่างต่อเนื่อง (ไม่ใช่แค่ความผันผวนปกติ) จากนั้นเก็บ **heap snapshots** ก่อน/หลังภาระงานหนึ่ง ๆ แล้วเปรียบเทียบเพื่อหาว่า object ชนิดใดกำลังสะสมขึ้น ("retained size" ที่กำลังโต)

## การแก้ไข 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
```

วิธีแก้สะท้อนกับสาเหตุโดยตรง: จำกัดขนาด cache (LRU พร้อม max size/TTL), จับคู่การสร้าง listener/timer กับการ cleanup เสมอ, และใช้ `WeakMap`/`WeakSet` สำหรับ metadata ที่ใช้ object เป็น key ซึ่งไม่ควรตรึง object ไว้ในหน่วยความจำ

## ทำไมจึงสำคัญ

Memory leak อันตรายเป็นพิเศษใน Node เพราะเซิร์ฟเวอร์ทำงาน **ต่อเนื่องเป็นเวลานาน** — leak ที่ช้าและมองไม่เห็นในตอน development จะค่อย ๆ ทำให้ประสิทธิภาพถดถอยและในที่สุดทำให้ process ใน production crash (มักรีสตาร์ทและสูญเสียงานที่กำลังดำเนินอยู่)

การรู้แหล่งที่มาคลาสสิก (cache ที่ไม่จำกัดขนาด, listener/timer ที่ไม่ถูกลบ, closure ที่ค้างอยู่), วิธีตรวจจับ (การ monitor heap + การเปรียบเทียบ snapshot ด้วย DevTools/clinic.js) และวิธีแก้ (cache แบบ LRU ที่มีขอบเขต, การ cleanup อย่างมีวินัย, `WeakMap`) เป็นสิ่งจำเป็นต่อการดูแล Node service ให้เชื่อถือได้และเสถียรในระยะยาว