Node.js Performance Tips

Node.js is known for its high-performance, event-driven architecture, but there are many techniques you can use to squeeze even more performance out of your applications. In this guide, we’ll explore proven strategies for optimizing Node.js applications.

Memory Management

Monitor Memory Usage

Use built-in tools to monitor memory consumption:

// Monitor memory usage
setInterval(() => {
  const used = process.memoryUsage();
  console.log({
    rss: `${Math.round((used.rss / 1024 / 1024) * 100) / 100} MB`,
    heapTotal: `${Math.round((used.heapTotal / 1024 / 1024) * 100) / 100} MB`,
    heapUsed: `${Math.round((used.heapUsed / 1024 / 1024) * 100) / 100} MB`,
    external: `${Math.round((used.external / 1024 / 1024) * 100) / 100} MB`,
  });
}, 5000);

Avoid Memory Leaks

Be careful with closures and event listeners:

// Bad: Potential memory leak
function createHandler() {
  const largeData = new Array(1000000).fill("data");

  return function (req, res) {
    // largeData is kept in memory even after handler is no longer used
    res.json({ message: "Hello" });
  };
}

// Good: Clean up references
function createHandler() {
  return function (req, res) {
    const largeData = new Array(1000000).fill("data");
    // largeData is garbage collected after function execution
    res.json({ message: "Hello" });
  };
}

Async Operations

Use Streams for Large Data

Process large files or data without loading everything into memory:

const fs = require("fs");
const { Transform } = require("stream");

// Bad: Loading entire file into memory
fs.readFile("large-file.txt", (err, data) => {
  if (err) throw err;
  // Process entire file at once
  processData(data);
});

// Good: Using streams
const readStream = fs.createReadStream("large-file.txt");
const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    // Process chunk by chunk
    const processed = processChunk(chunk);
    callback(null, processed);
  },
});

readStream.pipe(transformStream).pipe(process.stdout);

Optimize Database Queries

Use connection pooling and query optimization:

const { Pool } = require("pg");

// Connection pooling
const pool = new Pool({
  host: "localhost",
  database: "mydb",
  user: "user",
  password: "password",
  max: 20, // Maximum number of clients in the pool
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

// Optimized query with prepared statements
async function getUsers(limit = 10) {
  const client = await pool.connect();
  try {
    const result = await client.query(
      "SELECT id, name, email FROM users LIMIT $1",
      [limit]
    );
    return result.rows;
  } finally {
    client.release();
  }
}

Caching Strategies

Implement Redis Caching

Use Redis for fast data caching:

const redis = require("redis");
const client = redis.createClient();

// Cache expensive operations
async function getExpensiveData(key) {
  // Try to get from cache first
  const cached = await client.get(key);
  if (cached) {
    return JSON.parse(cached);
  }

  // If not in cache, compute and store
  const data = await computeExpensiveData();
  await client.setex(key, 3600, JSON.stringify(data)); // Cache for 1 hour
  return data;
}

Use HTTP Caching

Implement proper HTTP caching headers:

app.get("/api/data", (req, res) => {
  const data = getData();

  // Set cache headers
  res.set({
    "Cache-Control": "public, max-age=3600", // Cache for 1 hour
    ETag: generateETag(data),
    "Last-Modified": new Date().toUTCString(),
  });

  res.json(data);
});

Cluster Mode

Utilize Multiple CPU Cores

Use the cluster module to take advantage of multiple CPU cores:

const cluster = require("cluster");
const numCPUs = require("os").cpus().length;

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on("exit", (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Restart worker
  });
} else {
  // Worker process
  require("./app.js");
  console.log(`Worker ${process.pid} started`);
}

Profiling and Monitoring

Use Built-in Profiler

Enable Node.js built-in profiler:

# Start with profiling
node --prof app.js

# Process the profile
node --prof-process isolate-*.log > profile.txt

Monitor Event Loop Lag

Keep an eye on event loop performance:

const { performance, PerformanceObserver } = require("perf_hooks");

// Monitor event loop lag
const obs = new PerformanceObserver((list) => {
  const entries = list.getEntries();
  entries.forEach((entry) => {
    if (entry.duration > 100) {
      console.warn(`Event loop lag detected: ${entry.duration}ms`);
    }
  });
});

obs.observe({ entryTypes: ["measure"] });

// Measure event loop lag
setInterval(() => {
  const start = performance.now();
  setImmediate(() => {
    const lag = performance.now() - start;
    if (lag > 10) {
      console.warn(`Event loop lag: ${lag}ms`);
    }
  });
}, 1000);

Code Optimization

Use Native Modules

For CPU-intensive tasks, consider native modules:

// Use native crypto for better performance
const crypto = require("crypto");

function hashPassword(password) {
  return crypto.pbkdf2Sync(password, "salt", 100000, 64, "sha512");
}

Optimize JSON Operations

Use streaming JSON parsers for large JSON data:

const JSONStream = require("JSONStream");

// Stream large JSON files
fs.createReadStream("large-data.json")
  .pipe(JSONStream.parse("*"))
  .on("data", (data) => {
    // Process each object as it's parsed
    processData(data);
  });

Conclusion

Optimizing Node.js applications requires a combination of proper architecture, efficient algorithms, and careful monitoring. By implementing these performance tips, you can significantly improve your application’s speed and scalability.

Key takeaways:

• Monitor memory usage and avoid leaks
• Use streams for large data processing
• Implement proper caching strategies
• Utilize cluster mode for CPU-intensive applications
• Profile and monitor your application regularly
• Optimize database queries and async operations

Remember that performance optimization is an ongoing process. Regular monitoring and profiling will help you identify bottlenecks and improve your application over time.