Node.js Event Loop Blocking: The Silent API Killer and How to Fix It

// This is what "blocking the event loop" means in practice
const express = require('express');
const app = express();

app.get('/fast', (req, res) => {
 res.json({ status: 'ok' }); // Returns in < 1ms
});

app.get('/blocking', (req, res) => {
 // This runs synchronously — blocks ALL other requests for 2 seconds
 const start = Date.now();
 while (Date.now() - start < 2000) {} // Busy loop
 res.json({ status: 'done' });
});

// If one request hits /blocking:
// ALL concurrent requests to /fast also wait 2 seconds
// Even though /fast takes < 1ms
// This is the event loop blocking problem

// Parsing a 5MB JSON response — blocks for ~50ms
app.post('/process', (req, res) => {
 const data = JSON.parse(largeJsonString); // BLOCKING — 5MB = ~50ms
 res.json(transform(data));
});

// Fix: Use streaming JSON parser for large payloads
const { parser } = require('stream-json');
const { streamArray } = require('stream-json/streamers/StreamArray');

app.post('/process', (req, res) => {
 const pipeline = req.pipe(parser()).pipe(streamArray());
 pipeline.on('data', ({ value }) => processItem(value));
 pipeline.on('end', () => res.json({ done: true }));
});

// ❌ Every Sync fs call blocks ALL requests
const config = fs.readFileSync('./config.json'); // BLOCKING
const exists = fs.existsSync('./file.txt'); // BLOCKING
fs.writeFileSync('./log.txt', data); // BLOCKING

// ✅ Use async versions — they yield control back to the event loop
const config = await fs.promises.readFile('./config.json');
const exists = await fs.promises.access('./file.txt').then(() => true).catch(() => false);
await fs.promises.writeFile('./log.txt', data);

// ❌ bcrypt with high rounds blocks for 200-500ms
app.post('/login', async (req, res) => {
 const valid = bcrypt.compareSync(req.body.password, hash); // BLOCKING: ~300ms
 res.json({ valid });
});

// ✅ Use async version + run in worker thread for CPU-heavy crypto
const { Worker } = require('worker_threads');

// Or use argon2 which has better async support
const argon2 = require('argon2');
app.post('/login', async (req, res) => {
 const valid = await argon2.verify(hash, req.body.password); // Non-blocking
 res.json({ valid });
});

// ❌ Image processing, data transformation, sorting large arrays
app.get('/report', (req, res) => {
 const sorted = hugeArray.sort((a, b) => complexComparison(a, b)); // BLOCKING
 const processed = sorted.map(expensiveTransform); // BLOCKING
 res.json(processed);
});

// ✅ Offload CPU work to worker threads
const { Worker } = require('worker_threads');

function runInWorker(data) {
 return new Promise((resolve, reject) => {
 const worker = new Worker('./worker.js', { workerData: data });
 worker.on('message', resolve);
 worker.on('error', reject);
 });
}

app.get('/report', async (req, res) => {
 const result = await runInWorker(hugeArray); // Main thread stays free
 res.json(result);
});

// Method 1: Measure event loop lag with a simple timer
let lastCheck = Date.now();
setInterval(() => {
 const now = Date.now();
 const lag = now - lastCheck - 1000; // Should fire every 1000ms exactly
 if (lag > 50) {
 console.warn(`Event loop lag: ${lag}ms — something is blocking`);
 }
 lastCheck = now;
}, 1000);

// Method 2: Use clinic.js (best free tool for Node.js profiling)
// npm install -g clinic
// clinic doctor -- node server.js
// Generates a visual flame chart of blocking operations

// Method 3: Built-in perf_hooks
const { monitorEventLoopDelay } = require('perf_hooks');
const h = monitorEventLoopDelay({ resolution: 20 });
h.enable();
setInterval(() => {
 console.log('Event loop p99 delay:', h.percentile(99) / 1e6, 'ms');
 h.reset();
}, 5000);

// worker-pool.js — Reusable worker thread pool
const { Worker } = require('worker_threads');
const os = require('os');

class WorkerPool {
 constructor(workerScript, size = os.cpus().length) {
 this.workers = Array.from({ length: size }, () => ({
 worker: new Worker(workerScript),
 busy: false
 }));
 this.queue = [];
 }

 run(data) {
 return new Promise((resolve, reject) => {
 const available = this.workers.find(w => !w.busy);
 if (available) {
 this._runOnWorker(available, data, resolve, reject);
 } else {
 this.queue.push({ data, resolve, reject });
 }
 });
 }

 _runOnWorker(slot, data, resolve, reject) {
 slot.busy = true;
 slot.worker.postMessage(data);
 slot.worker.once('message', (result) => {
 slot.busy = false;
 resolve(result);
 if (this.queue.length > 0) {
 const next = this.queue.shift();
 this._runOnWorker(slot, next.data, next.resolve, next.reject);
 }
 });
 slot.worker.once('error', reject);
 }
}

// Usage
const pool = new WorkerPool('./compute-worker.js');
app.get('/compute', async (req, res) => {
 const result = await pool.run(req.body);
 res.json(result);
});