Node.js-இல் memory leaks-ஐ எப்படிக் கண்டறிந்து சரிசெய்வீர்கள்?

Question

Accepted Answer

**Memory leak** என்பது இனி தேவைப்படாத ஆனால் ஒருபோதும் விடுவிக்கப்படாத memory ஆகும், ஏனெனில் ஏதோ ஒன்று இன்னும் அதை reference செய்கிறது. காலப்போக்கில் process-இன் heap வளர்ந்து அது மெதுவாகிறது அல்லது crash ஆகிறது (out-of-memory). நீண்ட நேரம் இயங்கும் Node servers-இல், leaks ஒரு தீவிரமான 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
}
```

பொதுவான இழை: ஒரு reachable reference (ஒரு global Map, ஒரு live listener, ஒரு இயங்கும் timer, ஒரு closure) objects இனி பயனற்றதாக இருந்தாலும் அவை garbage-collected ஆவதைத் தடுக்கிறது.

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

கண்டறியும் செயல்முறை: heap நிலையாக வளர்கிறது என்பதை உறுதிப்படுத்துங்கள் (வெறும் சாதாரண ஏற்றஇறக்கம் அல்ல), பின்னர் ஒரு workload-க்கு முன்/பின் **heap snapshots** எடுத்து எந்த object வகைகள் குவிகின்றன என்பதைக் கண்டறிய ஒப்பிடுங்கள் ("retained size" வளர்கிறது).

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

சரிசெய்தல்கள் காரணங்களை பிரதிபலிக்கின்றன: caches-ஐ bound செய்யுங்கள் (max size/TTL உடன் LRU), listener/timer உருவாக்கத்தை எப்போதும் cleanup-உடன் இணைக்கவும், மற்றும் memory-இல் objects-ஐ pin செய்யக்கூடாத object-keyed metadata-க்கு `WeakMap`/`WeakSet`-ஐப் பயன்படுத்தவும்.

## இது ஏன் முக்கியம்

Node-இல் memory leaks குறிப்பாக ஆபத்தானவை, ஏனெனில் servers **நீண்ட நேரம் இயங்குபவை** — development-இல் கண்ணுக்குத் தெரியாத ஒரு மெதுவான leak படிப்படியாக சீரழிந்து இறுதியில் ஒரு production process-ஐ crash செய்கிறது (பெரும்பாலும் restart ஆகி in-flight வேலையை இழக்கிறது).

உன்னதமான ஆதாரங்களை (unbounded caches, அகற்றப்படாத listeners/timers, தங்கியிருக்கும் closures) அறிந்துகொள்வது, அவற்றை எப்படிக் கண்டறிவது (heap monitoring + DevTools/clinic.js உடன் snapshot ஒப்பீடு), மற்றும் சரிசெய்தல்கள் (bounded LRU caches, ஒழுங்கான cleanup, `WeakMap`) ஆகியவை காலப்போக்கில் நம்பகமான, நிலையான Node services-ஐ இயக்குவதற்கு அவசியம்.