Node.js 프로덕션 메모리 누수 디버깅: 실전 가이드와 해결 전략

// 메모리 누수 예제
let users = [];

function addUser(user) {
 users.push(user); // 계속 누적되지만 제거되지 않음
 //... 사용자 처리 로직
}

// 매 요청마다 호출되면 users 배열이 계속 커짐
app.post('/api/user', (req, res) => {
 addUser(req.body);
 res.json({ success: true });
});

┌─────────────────────────────────┐
│ RSS (Resident Set) │
├─────────────────────────────────┤
│ ┌──────────────────────────┐ │
│ │ V8 Heap Memory │ │
│ ├──────────────────────────┤ │
│ │ ├─ New Space (Young) │ │
│ │ ├─ Old Space (Old) │ │
│ │ ├─ Large Object Space │ │
│ │ └─ Code Space │ │
│ └──────────────────────────┘ │
│ ┌──────────────────────────┐ │
│ │ External Memory │ │
│ │ (Buffers, C++ Addons) │ │
│ └──────────────────────────┘ │
└─────────────────────────────────┘

// 나쁜 예: 전역 캐시가 계속 커짐
global.cache = {};

function cacheUser(userId, userData) {
 global.cache[userId] = userData;
 // 삭제 로직 없음
}

// 나쁜 예: 이벤트 리스너가 제거되지 않음
function setupListener() {
 const hugeData = new Array(1000000).fill('x');

 eventEmitter.on('data', () => {
 console.log(hugeData[0]); // 클로저가 hugeData 참조 유지
 });
}

// 여러 번 호출되면 메모리 누수
setInterval(setupListener, 1000);

// 나쁜 예: 타이머가 clear되지 않음
function processData() {
 const data = fetchLargeData();

 setInterval(() => {
 console.log(data.length);
 }, 1000);

 // data가 계속 메모리에 유지됨
}

// 나쁜 예: 요청 로그가 무한 증가
const requestLogs = [];

app.use((req, res, next) => {
 requestLogs.push({
 url: req.url,
 time: new Date(),
 headers: req.headers
 });
 next();
});

function logMemoryUsage() {
 const usage = process.memoryUsage();

 console.log({
 rss: `${Math.round(usage.rss / 1024 / 1024)} MB`, // 총 메모리
 heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)} MB`, // 할당된 힙
 heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)} MB`, // 사용 중인 힙
 external: `${Math.round(usage.external / 1024 / 1024)} MB`, // C++ 객체
 arrayBuffers: `${Math.round(usage.arrayBuffers / 1024 / 1024)} MB`
 });
}

// 매 10초마다 로깅
setInterval(logMemoryUsage, 10000);

정상: /\ /\ /\ /\
 / \/ \/ \/ \

누수: /\ /\ /\
 / \ / \ / \
 / \/ \/ \

const v8 = require('v8');
const fs = require('fs');

function takeHeapSnapshot() {
 const filename = `heap-${Date.now()}.heapsnapshot`;
 const snapshot = v8.writeHeapSnapshot(filename);
 console.log(`Heap snapshot written to ${snapshot}`);
 return snapshot;
}

// HTTP 엔드포인트로 제공
app.get('/debug/heap-snapshot', (req, res) => {
 const snapshot = takeHeapSnapshot();
 res.download(snapshot);
});

const v8 = require('v8');

// SIGUSR2 시그널 받으면 스냅샷 생성
process.on('SIGUSR2', () => {
 const filename = `heap-${process.pid}-${Date.now()}.heapsnapshot`;
 v8.writeHeapSnapshot(filename);
 console.log(`Heap snapshot saved: ${filename}`);
});

Chrome DevTools > Memory > Load

// 첫 번째 스냅샷
takeHeapSnapshot(); // heap-1.heapsnapshot

// 부하 생성 (예: 1000 요청 처리)
await processRequests(1000);

// 두 번째 스냅샷
takeHeapSnapshot(); // heap-2.heapsnapshot

const EventEmitter = require('events');
const emitter = new EventEmitter();

class DataProcessor {
 constructor(id) {
 this.id = id;
 this.data = new Array(100000).fill(`data-${id}`);

 // 리스너가 제거되지 않음
 emitter.on('process', () => {
 console.log(`Processing ${this.id}`);
 });
 }
}

// 매번 새 인스턴스 생성
app.post('/api/process', (req, res) => {
 new DataProcessor(req.body.id);
 res.json({ success: true });
});

Comparison View:
┌─────────────────┬─────────┬─────────┬─────────┐
│ Constructor │ #New │ #Deleted│ #Delta │
├─────────────────┼─────────┼─────────┼─────────┤
│ DataProcessor │ 1000 │ 0 │ +1000 │ ← 누수!
│ Array │ 1000 │ 0 │ +1000 │ ← 누수!
│ (closure) │ 1000 │ 0 │ +1000 │ ← 이벤트 리스너
└─────────────────┴─────────┴─────────┴─────────┘

class DataProcessor {
 constructor(id) {
 this.id = id;
 this.data = new Array(100000).fill(`data-${id}`);

 // bound function으로 참조 유지
 this.handleProcess = () => {
 console.log(`Processing ${this.id}`);
 };

 emitter.on('process', this.handleProcess);
 }

 // 명시적으로 정리
 cleanup() {
 emitter.off('process', this.handleProcess);
 this.data = null;
 }
}

app.post('/api/process', (req, res) => {
 const processor = new DataProcessor(req.body.id);

 // 작업 완료 후 정리
 setTimeout(() => {
 processor.cleanup();
 }, 5000);

 res.json({ success: true });
});

// 테스트 코드
const leakyArray = [];

setInterval(() => {
 // 매번 큰 객체 추가
 leakyArray.push({
 data: new Array(10000).fill('x'),
 timestamp: Date.now()
 });
}, 100);

// 수동 GC 트리거 (테스트용)
if (global.gc) {
 global.gc();
 console.log('Manual GC triggered');
}

// 나쁜 예: 강한 참조
const userCache = new Map();

function cacheUser(user) {
 userCache.set(user.id, user);
}

// 좋은 예: 약한 참조
const userCache = new WeakMap();
const userObjects = new Map(); // id -> user object

function cacheUser(user) {
 userObjects.set(user.id, user);
 userCache.set(user, user.metadata);
}

// user 객체가 GC되면 자동으로 WeakMap에서도 제거됨

class RequestHandler {
 constructor() {
 this.activeRequests = new Map();
 }

 async handleRequest(requestId, data) {
 try {
 const context = {
 id: requestId,
 data: data,
 startTime: Date.now()
 };

 this.activeRequests.set(requestId, context);

 await this.process(context);

 return { success: true };
 } finally {
 // 항상 정리
 this.activeRequests.delete(requestId);
 }
 }
}

class LRUCache {
 constructor(maxSize = 1000) {
 this.maxSize = maxSize;
 this.cache = new Map();
 }

 set(key, value) {
 // 이미 존재하면 제거 후 재추가 (LRU)
 if (this.cache.has(key)) {
 this.cache.delete(key);
 }

 this.cache.set(key, value);

 // 크기 제한
 if (this.cache.size > this.maxSize) {
 const firstKey = this.cache.keys().next().value;
 this.cache.delete(firstKey);
 }
 }

 get(key) {
 if (!this.cache.has(key)) {
 return undefined;
 }

 // LRU: 사용한 아이템을 끝으로 이동
 const value = this.cache.get(key);
 this.cache.delete(key);
 this.cache.set(key, value);

 return value;
 }
}

class Component {
 constructor() {
 this.listeners = new Set();
 }

 addEventListener(emitter, event, handler) {
 emitter.on(event, handler);
 this.listeners.add({ emitter, event, handler });
 }

 destroy() {
 // 모든 리스너 제거
 for (const { emitter, event, handler } of this.listeners) {
 emitter.off(event, handler);
 }
 this.listeners.clear();
 }
}

class Worker {
 constructor() {
 this.timers = new Set();
 }

 setInterval(fn, interval) {
 const timer = setInterval(fn, interval);
 this.timers.add(timer);
 return timer;
 }

 setTimeout(fn, delay) {
 const timer = setTimeout(() => {
 fn();
 this.timers.delete(timer); // 완료 후 제거
 }, delay);
 this.timers.add(timer);
 return timer;
 }

 cleanup() {
 // 모든 타이머 정리
 for (const timer of this.timers) {
 clearTimeout(timer);
 clearInterval(timer);
 }
 this.timers.clear();
 }
}

const fs = require('fs');

// 나쁜 예
function badReadFile(path) {
 const stream = fs.createReadStream(path);
 stream.on('data', chunk => {
 //... 처리
 });
 // 스트림이 닫히지 않을 수 있음
}

// 좋은 예
function goodReadFile(path) {
 return new Promise((resolve, reject) => {
 const stream = fs.createReadStream(path);
 const chunks = [];

 stream.on('data', chunk => chunks.push(chunk));
 stream.on('end', () => resolve(Buffer.concat(chunks)));
 stream.on('error', reject);

 // 정리 보장
 stream.on('close', () => {
 stream.removeAllListeners();
 });
 });
}