Noções Básicas de Desempenho

8 exemplos para você começar com Desempenho para backends Node.js - 6 básicos e 2 intermediários.

Pré-requisitos

• Node.js 24.18.0 instalado.
• Um serviço HTTP em execução (Express 5 ou Fastify 5) para realizar benchmarks.
• Opcional: npm install -g clinic para profiling (veja Clinic.js Suite).

Exemplos Básicos

1. Meça a Duração da Requisição com hrtime

Timers de alta resolução superam Date.now() para medição de latência.

import { createServer } from "node:http";
 
const server = createServer((req, res) => {
  const start = process.hrtime.bigint();
  res.end("ok");
  const elapsedMs = Number(process.hrtime.bigint() - start) / 1_000_000;
  console.log(JSON.stringify({ path: req.url, durationMs: elapsedMs }));
});
server.listen(3000);

• process.hrtime.bigint() é monotônico - não afetado por desvios de relógio.
• Registre JSON estruturado para que agregadores possam calcular p50/p95/p99.
• A medição do handler exclui o RTT da rede - combine com testes de carga para SLOs de ponta a ponta.

Relacionado: Testes de Carga - saturação e p95 sob concorrência

2. Monitore a Latência p95 no Código da Aplicação

Percentis importam mais que médias para SLOs de API.

const durations: number[] = [];
 
function recordDuration(ms: number): void {
  durations.push(ms);
  if (durations.length > 10_000) durations.shift();
}
 
function p95(): number {
  const sorted = [...durations].sort((a, b) => a - b);
  const idx = Math.ceil(sorted.length * 0.95) - 1;
  return sorted[idx] ?? 0;
}
 
// Exponha via /metrics ou registre a cada N requisições

• A latência média oculta requisições lentas na cauda que os usuários sentem.
• p95 é um alvo comum de SLO para APIs internas (p99 para as voltadas ao cliente).
• Em produção, exporte histogramas via OpenTelemetry ou Prometheus - não mantenha arrays em memória a longo prazo.

Relacionado: Métricas que Importam - RPS, p95, taxa de erros

3. Monitore o Atraso do Loop de Eventos

O atraso do loop atrasa todos os clientes concorrentes, não apenas uma rota lenta.

import { monitorEventLoopDelay } from "node:perf_hooks";
 
const histogram = monitorEventLoopDelay({ resolution: 20 });
histogram.enable();
 
setInterval(() => {
  console.log(JSON.stringify({
    event: "loop_delay",
    p99Ms: histogram.percentile(99) / 1e6,
    maxMs: histogram.max / 1e6,
  }));
  histogram.reset();
}, 10_000);

• monitorEventLoopDelay mede o quão atrasado o loop executa o trabalho agendado.
• Aumento do atraso p99 do loop com CPU moderada sinaliza bloqueio síncrono na thread principal.
• Alerte antes que o p95 voltado ao usuário dobre - o atraso do loop é um aviso antecipado.

Relacionado: Detectando Bloqueio do Loop de Eventos - ferramentas de atribuição

4. Use performance.mark para Caminhos Críticos

Marcas integradas se integram ao Chrome DevTools e ao clinic.js.

import { performance } from "node:perf_hooks";
 
async function fetchUser(id: string) {
  performance.mark("fetchUser:start");
  const user = await db.query("SELECT * FROM users WHERE id = $1", [id]);
  performance.mark("fetchUser:end");
  performance.measure("fetchUser", "fetchUser:start", "fetchUser:end");
  return user;
}

• Marcas são baratas quando usadas em caminhos de código limitados, não em cada linha.
• performance.getEntriesByName("fetchUser") retorna arrays de duração para análise.
• Limpe as marcas periodicamente em processos de longa duração para evitar crescimento de memória.

Relacionado: Clinic.js Suite - flame graphs para caminhos críticos

5. Linha de Base da Taxa de Transferência Antes de Ajustar

Conheça as requisições por segundo na concorrência alvo antes de alterar o código.

# Smoke rápido (não um teste de carga completo)
npx autocannon -c 50 -d 10 http://localhost:3000/health

• -c 50 simula 50 conexões concorrentes - mais próximo da produção do que um único curl.
• Registre RPS, latência p99 e taxa de erros como seu snapshot de linha de base.
• Reexecute após cada alegação de otimização - números superam a intuição.

Relacionado: Testes de Carga - cenários k6 e pontos de saturação

6. Limite o Tamanho da Carga no Limite (Edge)

Corpos JSON grandes bloqueiam a análise de forma síncrona na thread principal.

import express from "express";
 
const app = express();
app.use(express.json({ limit: "1mb" }));
 
app.post("/events", (req, res) => {
  // corpo já limitado - rejeita tamanhos excessivos no parser
  res.status(201).json({ ok: true });
});

• limit retorna 413 antes que seu handler seja executado - economiza CPU em abusos.
• Combine com otimização da forma da resposta - retorne apenas os campos que os clientes precisam.
• Endpoints de streaming precisam de limites diferentes de APIs CRUD JSON.

Relacionado: Custo de Serialização JSON - otimização da forma da resposta

Exemplos Intermediários

7. Script de Teste de Carga Semelhante à Produção

Concorrência sustentada revela bloqueios que requisições únicas escondem.

// Script k6 - salve como load-test.js
import http from "k6/http";
import { check, sleep } from "k6";
 
export const options = {
  stages: [
    { duration: "1m", target: 50 },
    { duration: "3m", target: 50 },
    { duration: "1m", target: 0 },
  ],
  thresholds: { http_req_duration: ["p(95)<200"] },
};
 
export default function () {
  const res = http.get("http://localhost:3000/users");
  check(res, { "status is 200": (r) => r.status === 200 });
  sleep(0.1);
}

• Aumente gradualmente - tráfego de pico instantâneo testa o gerador de carga, não seu app de forma justa.
• thresholds falha a execução quando p95 excede 200ms - controle merges em regressões.
• Execute em staging com volume de dados e tamanhos de pool de conexões semelhantes aos de produção.

Relacionado: Desempenho no Express - ajuste do Express sob carga

8. Snapshot do Heap Quando a Memória Cresce

Vazamentos suspeitos precisam de evidências antes de ajustar --max-old-space-size.

import { writeHeapSnapshot } from "node:v8";
import { writeFileSync } from "node:fs";
 
function captureHeap(label: string): void {
  const path = writeHeapSnapshot();
  writeFileSync(`/tmp/heap-${label}.json`, ""); // arquivo marcador
  console.log(JSON.stringify({ event: "heap_snapshot", label, path }));
}
 
// Chame em SIGUSR2 ou após N requisições em staging
process.on("SIGUSR2", () => captureHeap("manual"));

• Compare dois snapshots no Chrome DevTools para encontrar objetos retidos.
• Não tire snapshots em produção sob tráfego - pausa o processo.
• Corrija vazamentos antes de aumentar os limites do heap - heaps maiores atrasam a dor do GC, não a causa raiz.

Relacionado: Ajuste de Memória e GC - --max-old-space-size e flags de GC

Versões da Stack: Esta página foi escrita para Node.js 24.18.0 (Active LTS), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 e NestJS 11.