Performance do Node.js: Event Loop, Clustering e Otimização em 2026

// Demonstração da ordem de execução das fases

const fs = require('fs');

// Fase 1: Timers — executa callbacks de setTimeout/setInterval
setTimeout(() => console.log('1. Timer phase'), 0);

// Fase 4: Poll — executa callbacks de I/O
fs.readFile(__filename, () => {
  console.log('2. Poll phase (I/O callback)');

  // Fase 5: Check — executa callbacks de setImmediate
  setImmediate(() => console.log('3. Check phase (setImmediate)'));

  // Fase 1 novamente: Timer agendado a partir de I/O
  setTimeout(() => console.log('4. Timer phase (from I/O)'), 0);
});

// Microtask — executa entre cada transição de fase
Promise.resolve().then(() => console.log('Microtask: Promise'));
process.nextTick(() => console.log('Microtask: nextTick'));

// Monitoramento do event loop de nível produção

const { performance, monitorEventLoopDelay } = require('perf_hooks');

// Histograma de alta resolução do atraso do event loop
const histogram = monitorEventLoopDelay({ resolution: 20 });
histogram.enable();

// Rastreamento da utilização por intervalos
let previous = performance.eventLoopUtilization();

setInterval(() => {
  const current = performance.eventLoopUtilization(previous);
  previous = performance.eventLoopUtilization();

  const metrics = {
    // Razão entre tempo ativo e inativo do loop (0-1)
    utilization: current.utilization.toFixed(3),
    // Percentis de atraso em milissegundos
    p50: (histogram.percentile(50) / 1e6).toFixed(2),
    p99: (histogram.percentile(99) / 1e6).toFixed(2),
    max: (histogram.max / 1e6).toFixed(2),
  };

  // Alerta quando a utilização ultrapassa 70% ou p99 > 100ms
  if (current.utilization > 0.7 || histogram.percentile(99) > 100e6) {
    console.warn('EVENT_LOOP_SATURATED', metrics);
  }

  histogram.reset();
}, 5000);

// Anti-padrões e suas soluções

// PROBLEMA: JSON.parse bloqueia em payloads grandes
const largePayload = Buffer.alloc(50 * 1024 * 1024); // 50MB
// JSON.parse(largePayload.toString()); // Bloqueia o event loop por 200-500ms

// SOLUÇÃO: Fazer parse em streaming com parser adequado
const { Transform } = require('stream');
const JSONStream = require('jsonstream2');

function processLargeJSON(readableStream) {
  return new Promise((resolve, reject) => {
    const results = [];
    readableStream
      .pipe(JSONStream.parse('items.*'))  // Parse em streaming dos itens do array
      .on('data', (item) => results.push(item))
      .on('end', () => resolve(results))
      .on('error', reject);
  });
}

// PROBLEMA: Crypto síncrono no caminho da requisição
// const hash = crypto.pbkdf2Sync(password, salt, 100000, 64, 'sha512');

// SOLUÇÃO: Usar a variante assíncrona
const crypto = require('crypto');
async function hashPassword(password, salt) {
  return new Promise((resolve, reject) => {
    crypto.pbkdf2(password, salt, 100000, 64, 'sha512', (err, key) => {
      if (err) reject(err);
      else resolve(key.toString('hex'));
    });
  });
}

// Clustering de produção com desligamento gracioso

const cluster = require('cluster');
const os = require('os');
const process = require('process');

const WORKER_COUNT = parseInt(process.env.WORKERS) || os.cpus().length;

if (cluster.isPrimary) {
  console.log(`Primary ${process.pid} starting ${WORKER_COUNT} workers`);

  // Fork de um worker por core de CPU
  for (let i = 0; i < WORKER_COUNT; i++) {
    cluster.fork();
  }

  // Reinício automático de workers que falharam
  cluster.on('exit', (worker, code, signal) => {
    if (!worker.exitedAfterDisconnect) {
      console.error(`Worker ${worker.process.pid} died (${signal || code}). Restarting...`);
      cluster.fork();
    }
  });

  // Desligamento gracioso no SIGTERM
  process.on('SIGTERM', () => {
    console.log('Primary received SIGTERM. Shutting down workers...');
    for (const id in cluster.workers) {
      cluster.workers[id].disconnect();
    }
  });
} else {
  // Processo worker — iniciar o servidor HTTP
  const http = require('http');
  const server = http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Handled by worker ${process.pid}\n`);
  });

  server.listen(3000, () => {
    console.log(`Worker ${process.pid} listening on port 3000`);
  });

  // Desligamento gracioso do worker individual
  process.on('SIGTERM', () => {
    server.close(() => process.exit(0));
  });
}

// Pool de worker threads reutilizável para tarefas de CPU

const { Worker } = require('worker_threads');
const os = require('os');

class WorkerPool {
  constructor(workerScript, poolSize = os.cpus().length) {
    this.workers = [];
    this.queue = [];

    for (let i = 0; i < poolSize; i++) {
      this.workers.push({ busy: false, worker: new Worker(workerScript) });
    }
  }

  execute(taskData) {
    return new Promise((resolve, reject) => {
      const available = this.workers.find(w => !w.busy);

      if (available) {
        this._runTask(available, taskData, resolve, reject);
      } else {
        // Enfileirar a tarefa até que um worker esteja livre
        this.queue.push({ taskData, resolve, reject });
      }
    });
  }

  _runTask(entry, taskData, resolve, reject) {
    entry.busy = true;
    entry.worker.postMessage(taskData);

    const onMessage = (result) => {
      entry.busy = false;
      cleanup();
      resolve(result);
      this._processQueue();
    };

    const onError = (err) => {
      entry.busy = false;
      cleanup();
      reject(err);
      this._processQueue();
    };

    const cleanup = () => {
      entry.worker.removeListener('message', onMessage);
      entry.worker.removeListener('error', onError);
    };

    entry.worker.on('message', onMessage);
    entry.worker.on('error', onError);
  }

  _processQueue() {
    if (this.queue.length === 0) return;
    const available = this.workers.find(w => !w.busy);
    if (available) {
      const { taskData, resolve, reject } = this.queue.shift();
      this._runTask(available, taskData, resolve, reject);
    }
  }
}

module.exports = { WorkerPool };

// Worker thread para processamento de imagens intensivo em CPU

const { parentPort } = require('worker_threads');
const sharp = require('sharp');

parentPort.on('message', async ({ inputPath, width, height }) => {
  const result = await sharp(inputPath)
    .resize(width, height)
    .webp({ quality: 80 })
    .toBuffer();

  parentPort.postMessage({ size: result.length, buffer: result });
});

// Padrões que reduzem a pressão sobre o GC

// ANTI-PADRÃO: Criar objetos em loops críticos
function processItemsBad(items) {
  return items.map(item => ({
    id: item.id,
    name: item.name.trim(),
    score: calculateScore(item),
    metadata: { processed: true, timestamp: Date.now() }
  }));
}

// OTIMIZADO: Reutilizar buffers e minimizar alocações
const reusableBuffer = Buffer.alloc(4096);

function processItemsGood(items, output) {
  // Reutilizar o array de saída em vez de criar um novo
  output.length = 0;
  for (let i = 0; i < items.length; i++) {
    // Mutação in-place quando seguro
    output.push(items[i].id);
  }
  return output;
}

// Monitoramento do uso do heap para detecção de vazamentos
function checkMemory() {
  const used = process.memoryUsage();
  return {
    heapUsedMB: Math.round(used.heapUsed / 1024 / 1024),
    heapTotalMB: Math.round(used.heapTotal / 1024 / 1024),
    externalMB: Math.round(used.external / 1024 / 1024),
    rsssMB: Math.round(used.rss / 1024 / 1024),
  };
}

// Flags do V8 para ajuste do GC em produção
// node --max-old-space-size=4096 --max-semi-space-size=128 app.js
// --max-old-space-size: Limite da geração antiga (padrão ~1.7GB)
// --max-semi-space-size: Aumentar a geração jovem (padrão 16MB)

// Configuração do OpenTelemetry para monitoramento de performance Node.js

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');
const { PeriodicExportingMetricReader } = require('@opentelemetry/sdk-metrics');

const sdk = new NodeSDK({
  metricReader: new PrometheusExporter({ port: 9464 }),
  instrumentations: [
    getNodeAutoInstrumentations({
      // Instrumentar HTTP, Express, DNS, fs e mais
      '@opentelemetry/instrumentation-fs': { enabled: false }, // Muito verboso
    }),
  ],
});

sdk.start();

// Métrica personalizada de lag do event loop
const { metrics } = require('@opentelemetry/api');
const meter = metrics.getMeter('app');

const eventLoopLag = meter.createHistogram('nodejs.event_loop.lag', {
  description: 'Event loop lag in milliseconds',
  unit: 'ms',
});

// Reportar o lag do event loop a cada segundo
const { monitorEventLoopDelay } = require('perf_hooks');
const h = monitorEventLoopDelay({ resolution: 10 });
h.enable();

setInterval(() => {
  eventLoopLag.record(h.percentile(99) / 1e6);
  h.reset();
}, 1000);