Memory leak detection and prevention

Concept and Impact of Memory Leaks

Memory leaks occur when a program fails to properly release memory that is no longer in use during execution, leading to a continuous increase in memory consumption. This phenomenon is particularly noticeable in long-running applications like Express servers. Memory leaks gradually consume system resources and may eventually cause application crashes or severe performance degradation. In the Node.js environment, due to the garbage collection mechanism of the V8 engine, memory leaks may not manifest immediately, but the problem worsens over time.

Common Memory Leak Scenarios

Uncleared Timers

// Bad example: Uncleared timer
const express = require('express');
const app = express();

app.get('/leaky', (req, res) => {
  setInterval(() => {
    console.log('This interval keeps running even after request is handled');
  }, 1000);
  res.send('Response sent');
});

app.listen(3000);

In this example, each visit to the /leaky route creates a new timer that is never cleared. The correct approach is to clean up timers after request handling:

// Correct approach: Clearing timers
app.get('/non-leaky', (req, res) => {
  const intervalId = setInterval(() => {
    console.log('This will be cleaned up');
  }, 1000);
  
  // Set timeout for automatic cleanup
  setTimeout(() => {
    clearInterval(intervalId);
  }, 5000);
  
  res.send('Response with cleanup');
});

Unreleased Event Listeners

// Bad example: Unremoved event listeners
const EventEmitter = require('events');
const emitter = new EventEmitter();

app.get('/event-leak', (req, res) => {
  const handler = () => console.log('Event handled');
  emitter.on('someEvent', handler);
  res.send('Event listener added');
});

Each request adds a new event listener that is never removed. Listeners should be removed after use:

// Correct approach: Removing event listeners
app.get('/event-safe', (req, res) => {
  const handler = () => {
    console.log('Event handled once');
    emitter.off('someEvent', handler); // Remove after handling
  };
  emitter.on('someEvent', handler);
  res.send('Event listener with cleanup');
});

Accumulation in Global Variables

// Bad example: Global variable accumulation
const cache = {};

app.get('/cache-leak', (req, res) => {
  const key = req.query.key;
  const value = req.query.value;
  cache[key] = value; // Continuously growing global cache
  res.send('Value cached');
});

This unlimited cache growth leads to memory leaks. Implement cache size limits or expiration policies:

// Correct approach: Limiting cache size
const MAX_CACHE_SIZE = 100;
const safeCache = new Map();

app.get('/cache-safe', (req, res) => {
  const key = req.query.key;
  const value = req.query.value;
  
  if (safeCache.size >= MAX_CACHE_SIZE) {
    // Remove the oldest entry
    const firstKey = safeCache.keys().next().value;
    safeCache.delete(firstKey);
  }
  
  safeCache.set(key, value);
  res.send('Value cached safely');
});

Memory Leak Detection Tools

Built-in Node.js Tools

Node.js provides various memory analysis tools, most commonly the combination of the --inspect flag and Chrome DevTools:

node --inspect your-express-app.js

Then visit chrome://inspect in Chrome to connect to the Node.js process for memory analysis.

heapdump and v8-profiler

const heapdump = require('heapdump');
const profiler = require('v8-profiler-next');

app.get('/heapdump', (req, res) => {
  const filename = `/tmp/heapdump-${Date.now()}.heapsnapshot`;
  heapdump.writeSnapshot(filename, (err) => {
    if (err) console.error(err);
    res.send(`Heap dump written to ${filename}`);
  });
});

app.get('/cpu-profile', (req, res) => {
  const profile = profiler.startProfiling('CPU profile');
  setTimeout(() => {
    profile.end().then(result => {
      const filename = `/tmp/cpu-profile-${Date.now()}.cpuprofile`;
      require('fs').writeFileSync(filename, JSON.stringify(result));
      res.send(`CPU profile written to ${filename}`);
    });
  }, 5000);
});

Clinic.js

Clinic.js is a professional suite of Node.js performance diagnostics tools for easy memory issue detection:

npm install -g clinic
clinic doctor -- node your-express-app.js

Memory Leak Prevention Strategies

Code Review and Best Practices

1. Ensure cleanup logic exists for all setInterval and setTimeout
2. Use WeakMap and WeakSet instead of regular Map and Set for temporary data
3. Avoid storing large amounts of data in global scope
4. Use closures cautiously to prevent accidental retention of large object references

Resource Management Middleware

Create an Express middleware to track and clean up resources:

function resourceTracker(req, res, next) {
  req._resources = {
    timers: new Set(),
    eventListeners: new Map(),
    fileHandles: new Set()
  };
  
  // Override res.end to ensure resource cleanup
  const originalEnd = res.end;
  res.end = function(...args) {
    cleanupResources(req._resources);
    return originalEnd.apply(this, args);
  };
  
  next();
}

function cleanupResources(resources) {
  // Clear all timers
  resources.timers.forEach(clearInterval);
  resources.timers.clear();
  
  // Remove all event listeners
  resources.eventListeners.forEach((listeners, emitter) => {
    listeners.forEach(([event, handler]) => {
      emitter.off(event, handler);
    });
  });
  resources.eventListeners.clear();
  
  // Close all file handles
  resources.fileHandles.forEach(handle => handle.close());
  resources.fileHandles.clear();
}

// Using the middleware
app.use(resourceTracker);

// Example of safely adding a timer
app.get('/safe-timer', (req, res) => {
  const timer = setInterval(() => {
    console.log('Safe timer running');
  }, 1000);
  
  // Register with request resources
  req._resources.timers.add(timer);
  
  res.send('Timer will be automatically cleaned up');
});

Automated Testing and Monitoring

Implement memory monitoring middleware:

const memwatch = require('node-memwatch');

// Memory monitoring middleware
function memoryMonitor(req, res, next) {
  if (!process.memoryMonitorEnabled) {
    process.memoryMonitorEnabled = true;
    
    const hd = new memwatch.HeapDiff();
    const interval = setInterval(() => {
      const diff = hd.end();
      console.log('Heap diff:', diff);
      
      if (diff.change.size_bytes > 1000000) { // 1MB increase
        console.warn('Significant memory increase detected');
      }
      
      hd = new memwatch.HeapDiff();
    }, 60000); // Check every minute
    
    // Ensure cleanup on process exit
    process.on('exit', () => clearInterval(interval));
  }
  
  next();
}

app.use(memoryMonitor);

Express-Specific Memory Leak Scenarios

Leaks in Middleware

// Bad example: Middleware retaining request references
app.use((req, res, next) => {
  req.someData = loadHugeData(); // Loading large data
  next();
});

// Even after request ends, someData remains in memory

Solution is timely cleanup:

app.use((req, res, next) => {
  req.someData = loadHugeData();
  
  // Ensure cleanup after request completion
  res.on('finish', () => {
    req.someData = null;
  });
  
  next();
});

Session Storage Leaks

Memory leaks are common when using in-memory session storage:

// Not recommended: In-memory session storage
const session = require('express-session');
app.use(session({
  secret: 'your-secret',
  resave: false,
  saveUninitialized: true,
  cookie: { secure: true }
}));

Use external storage like Redis instead:

const RedisStore = require('connect-redis')(session);
app.use(session({
  store: new RedisStore({
    host: 'localhost',
    port: 6379
  }),
  secret: 'your-secret',
  resave: false,
  saveUninitialized: true,
  cookie: { secure: true }
}));

Large File Upload Handling

Improper handling of file uploads can cause memory issues:

// Bad example: Using memory storage for large files
const multer = require('multer');
const upload = multer(); // Default memory storage

app.post('/upload', upload.single('largeFile'), (req, res) => {
  // Large files are fully loaded into memory
  res.send('File uploaded');
});

Use disk storage instead:

const storage = multer.diskStorage({
  destination: '/tmp/uploads',
  filename: (req, file, cb) => {
    cb(null, `${Date.now()}-${file.originalname}`);
  }
});
const upload = multer({ storage });

app.post('/upload-safe', upload.single('largeFile'), (req, res) => {
  res.send('File uploaded safely');
});

Advanced Memory Management Techniques

Stream Processing Optimization

Using streams can significantly reduce memory usage:

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

// Efficient large file handling
app.get('/large-file', (req, res) => {
  const fileStream = fs.createReadStream('/path/to/large/file');
  const gzip = zlib.createGzip();
  
  res.setHeader('Content-Encoding', 'gzip');
  fileStream.pipe(gzip).pipe(res);
});

// Streaming JSON response
app.get('/large-json', (req, res) => {
  const data = getLargeDataset(); // Returns iterable
  
  res.writeHead(200, {
    'Content-Type': 'application/json'
  });
  
  res.write('[');
  let first = true;
  
  for (const item of data) {
    if (!first) res.write(',');
    first = false;
    res.write(JSON.stringify(item));
  }
  
  res.end(']');
});

Object Pooling Technique

For frequently created and destroyed objects, use object pools:

class DatabaseConnectionPool {
  constructor(maxSize) {
    this.maxSize = maxSize;
    this.pool = [];
    this.waiting = [];
  }

  async getConnection() {
    if (this.pool.length > 0) {
      return this.pool.pop();
    }
    
    if (this.pool.length + this.waiting.length < this.maxSize) {
      return this.createNewConnection();
    }
    
    return new Promise(resolve => {
      this.waiting.push(resolve);
    });
  }

  releaseConnection(conn) {
    if (this.waiting.length > 0) {
      const resolve = this.waiting.shift();
      resolve(conn);
    } else {
      this.pool.push(conn);
    }
  }

  async createNewConnection() {
    // Simulate database connection creation
    await new Promise(resolve => setTimeout(resolve, 100));
    return { id: Date.now() };
  }
}

const pool = new DatabaseConnectionPool(10);

app.get('/db-query', async (req, res) => {
  const conn = await pool.getConnection();
  try {
    // Execute query using connection
    await new Promise(resolve => setTimeout(resolve, 50));
    res.send('Query executed');
  } finally {
    pool.releaseConnection(conn);
  }
});

Memory Limits and Graceful Degradation

Implement memory limiting mechanisms with fallback strategies when usage is high:

const os = require('os');

function checkMemoryUsage() {
  const free = os.freemem();
  const total = os.totalmem();
  const used = total - free;
  const percentage = (used / total) * 100;
  
  return {
    free: free / 1024 / 1024, // MB
    total: total / 1024 / 1024, // MB
    percentage
  };
}

// Memory protection middleware
function memoryProtection(req, res, next) {
  const { percentage } = checkMemoryUsage();
  
  if (percentage > 80) {
    // Memory usage exceeds 80%, initiate degradation
    req.memoryCritical = true;
    
    // Return 503 for non-critical requests
    if (!req.path.startsWith('/critical')) {
      return res.status(503).send('Service temporarily unavailable due to high memory usage');
    }
  }
  
  next();
}

app.use(memoryProtection);

// Critical route
app.get('/critical/data', (req, res) => {
  if (req.memoryCritical) {
    // Return minimal data when memory is tight
    res.json({ status: 'minimal' });
  } else {
    // Return full data normally
    res.json({ status: 'full', data: getFullData() });
  }
});

Memory Management for Long-Running Applications

Scheduled Restart Strategy

For long-running Express applications, implement planned restarts:

const MAX_UPTIME = 24 * 60 * 60 * 1000; // 24 hours
const startTime = Date.now();

// Health check endpoint for restart determination
app.get('/health', (req, res) => {
  const uptime = Date.now() - startTime;
  const memory = checkMemoryUsage();
  
  res.json({
    status: uptime > MAX_UPTIME ? 'needs-restart' : 'healthy',
    uptime: uptime / 1000 / 60 / 60, // hours
    memory
  });
});

// Process managers like PM2 can enable automatic restarts
// Or implement graceful shutdown in code
process.on('SIGTERM', () => {
  console.log('Received SIGTERM, shutting down gracefully');
  server.close(() => {
    console.log('Server closed');
    process.exit(0);
  });
  
  // Force exit if timeout exceeded
  setTimeout(() => {
    console.error('Could not close connections in time, forcefully shutting down');
    process.exit(1);
  }, 5000);
});

Automated Memory Leak Detection

Implement an automated memory leak detection system:

const { performance, PerformanceObserver } = require('perf_hooks');
const { EventEmitter } = require('events');

class MemoryLeakDetector extends EventEmitter {
  constructor(options = {}) {
    super();
    this.interval = options.interval || 60000; // 1 minute
    this.threshold = options.threshold || 10; // 10MB increase
    this.heapDiffs = [];
    this.maxRecords = options.maxRecords || 10;
    this.timer = null;
  }
  
  start() {
    if (this.timer) return;
    
    this.timer = setInterval(() => {
      const hd = new memwatch.HeapDiff();
      this.heapDiffs.push(hd);
      
      if (this.heapDiffs.length > this.maxRecords) {
        this.heapDiffs.shift();
      }
      
      if (this.heapDiffs.length >= 2) {
        const diff = memwatch.HeapDiff.compare(
          this.heapDiffs[this.heapDiffs.length - 2].before,
          this.heapDiffs[this.heapDiffs.length - 1].after
        );
        
        if (diff.change.size_bytes > this.threshold * 1024 * 1024) {
          this.emit('leak', {
            increase: diff.change.size_bytes / 1024 / 1024,
            details: diff
          });
        }
      }
    }, this.interval);
  }
  
  stop() {
    if (this.timer) {
      clearInterval(this.timer);
      this.timer = null;
    }
  }
}

// Using the detector
const detector = new MemoryLeakDetector({
  threshold: 5, // 5MB
  interval: 30000 // 30 seconds
});

detector.on('leak', ({ increase, details }) => {
  console.error(`Memory leak detected: ${increase.toFixed(2)}MB increase`);
  // Can trigger alerts or automatically collect more diagnostic info
  heapdump.writeSnapshot(`/tmp/leak-${Date.now()}.heapsnapshot`, console.error);
});

detector.start();

// Stop detection on application shutdown
process.on('beforeExit', () => detector.stop());