Node.js fornece ferramentas poderosas para medir e otimizar o desempenho de suas aplicações. Uma dessas ferramentas é a Performance API, que permite aos desenvolvedores capturar timestamps de alta resolução e várias métricas de desempenho. Este guia irá apresentar os principais componentes da Performance API do Node.js e como usá-los de forma eficaz.
Por que o Desempenho é Importante no Node.js
Node.js brilha em sua arquitetura assíncrona orientada a eventos, perfeitamente adequada para tarefas limitadas por I/O. No entanto, mesmo nesse ambiente não bloqueante, o desempenho continua sendo primordial. Aplicações lentas levam a usuários frustrados e dificultam a escalabilidade. Identificar gargalos e otimizar o código torna-se essencial para uma experiência de usuário tranquila.
Interessado em aumentar o tempo de resposta da sua API? O artigo a seguir oferece um guia passo a passo sobre como aumentar o tempo de resposta da sua API.
Por que Usar a Performance API do Node.js?
- Identificar Gargalos de Desempenho: Gargalos de desempenho podem degradar significativamente a experiência do usuário. Usando a Performance API, os desenvolvedores podem identificar momentos exatos em que ocorrem atrasos, seja na execução de funções, no carregamento de recursos ou no tratamento de requisições HTTP. Essa precisão permite otimizações direcionadas.
- Otimizar o Uso de Recursos: Monitorar o desempenho ajuda a entender como recursos como CPU e memória estão sendo utilizados. Ao identificar o uso ineficiente de recursos, os desenvolvedores podem otimizar seu código para ser mais eficiente, reduzindo custos e melhorando a escalabilidade.
- Aprimorar a Experiência do Usuário: Aplicações que respondem rapidamente oferecem uma melhor experiência ao usuário. A Performance API ajuda a medir métricas-chave como Tempo até o Primeiro Byte (TTFB) e Primeiro Pintar de Conteúdo (FCP), permitindo que os desenvolvedores façam melhorias que levam a tempos de carregamento mais rápidos e interações mais suaves.
- Melhorar a Estabilidade da Aplicação: O monitoramento contínuo de desempenho ajuda na detecção de anomalias e problemas potenciais antes que se tornem críticos. Essa abordagem proativa garante maior uptime e confiabilidade da aplicação.
Introdução à Performance API do Node.js
A Performance API, acessível através do módulo perf_hooks, fornece aos desenvolvedores do Node.js um conjunto abrangente de ferramentas para medir e analisar o desempenho da aplicação. Ela oferece uma vantagem significativa sobre métodos tradicionais como Date.now(), proporcionando temporização de alta resolução e uma abordagem mais estruturada para avaliação de desempenho. No método Date.now(), você verá algo como;
const startTime = Date.now();
// chame uma função para executar uma tarefa()
console.log(`Duração da tarefa: ${Date.now() - startTime} milissegundos`);
A função Date.now() funciona bem, mas novamente, embora aparentemente simples, esse método pode ser pouco confiável, pois mudanças no relógio do sistema podem afetar as medições.
É aqui que a Performance API do Node.js entra em cena. Queremos ser capazes de medir totalmente o uso do tempo da nossa aplicação e não nos preocupar com coisas como o relógio do sistema, certo?
A Performance API do Node.js é construída em torno de vários métodos e classes fundamentais fornecidos pelo módulo perf_hooks. Estes incluem:
Cada uma dessas ferramentas serve a um propósito distinto na captura e análise de métricas de desempenho.
Usando performance.now()
O método performance.now() retorna um timestamp de alta resolução em milissegundos. Isso é útil para medir intervalos dentro da sua aplicação com maior precisão do que Date.now().
Para obter a duração de uma tarefa, adicione o método performance.now() no início e no final da operação que você deseja medir da seguinte forma;
const { performance } = require('node:perf_hooks');
const start = performance.now();
// Execute algumas operações
const end = performance.now();
console.log(`Tempo levado: ${end - start} ms`);
Primeiramente, importamos o performance dos módulos do node, e depois criamos constantes de início e fim e atribuímos os métodos performance.now a elas para obter o tempo preciso da operação.
A saída do código acima deve parecer com o seguinte;
Tempo levado: 1253.**** ms.Usando performance.mark()
O método performance.mark() no Node.js permite que você crie timestamps nomeados (ou marcas) em pontos específicos do seu código. Essas marcas ajudam você a medir o tempo levado entre diferentes partes da sua aplicação, dando insights sobre gargalos de desempenho.
const { performance } = require('node:perf_hooks');
performance.mark('A');
// Algumas operações
performance.mark('B');
Neste exemplo, performance.mark('A') e performance.mark('B') criam duas marcas rotuladas 'A' e 'B', respectivamente.
As marcas também podem incluir detalhes adicionais, que podem ser úteis para depuração ou análise posterior.performance.mark('A', { detail: 'Início da operação' }); performance.mark('B', { detail: 'Fim da operação' });
Aqui, a propriedade detail fornece informações extras sobre o que cada marca representa.
Uma vez que você tenha criado marcas, pode medir a duração entre elas usando performance.measure().
Usando performance.measure()
performance.measure() é uma função dentro da Performance API do Node.js que calcula especificamente a duração entre dois pontos marcados na linha do tempo de execução da sua aplicação. Essencialmente, ela cria uma entrada de medição e armazena o tempo decorrido para recuperação e análise posterior.
Lembre-se que na seção performance.mark(), criamos duas marcas: A & B. Nesta seção, testaremos elas e veremos como o performance.mark() funciona com performance.measure().
performance.measure('A para B', 'A', 'B');
const measures = performance.getEntriesByType('measure');
measures.forEach(measure => {
console.log(`${measure.name}: ${measure.duration}ms`);
});
Isso irá criar uma medida chamada 'A para B', que calcula o tempo decorrido entre as marcas 'A' e 'B'.
Quando você executar o código acima, a saída exibirá a duração entre as duas marcas 'A' e 'B'. Aqui está um exemplo de como o console pode exibir algo como:
A para B: 12.345ms
Essa saída indica que as operações entre as marcas 'A' e 'B' levaram aproximadamente 12.345 milissegundos para serem concluídas.
Usando PerformanceObserver
A interface PerformanceObserver no Node.js permite que os desenvolvedores observem e tratem entradas de desempenho como marcas, medições e entradas de temporização de recursos de forma assíncrona. É particularmente útil para monitorar e reagir a dados de desempenho à medida que são coletados, tornando-se uma ferramenta essencial para análise e otimização de desempenho em tempo real.
Para usar o PerformanceObserver, você precisa criar uma instância dele e definir uma função de callback que irá tratar as entradas de desempenho. Aqui está uma configuração básica:
const { PerformanceObserver, performance } = require('node:perf_hooks');
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => {
console.log(entry);
});
});
observer.observe({ entryTypes: ['mark', 'measure'] });
Neste exemplo:
- Importando
PerformanceObservereperformance: Os objetosPerformanceObservereperformancesão importados do móduloperf_hooks. - Criando um Observador: Uma instância de
PerformanceObserveré criada com uma função de callback. Esta função é chamada sempre que novas entradas de desempenho são registradas. - Observando Tipos de Entrada: O método
observer.observeé chamado com um objeto especificando os tipos de entradas para observar (markemeasureneste caso).
Casos de Uso Práticos para o PerformanceObserver
1. Monitoramento de Desempenho em Tempo Real:
PerformanceObserverpermite que você monitore continuamente o desempenho da aplicação, fornecendo feedback imediato sobre problemas de desempenho. Isso é particularmente útil em ambientes de produção onde dados de desempenho em tempo real são críticos.
2. Análise do Carregamento de Recursos:
- Ao observar entradas de temporização de recursos, os desenvolvedores podem analisar como vários recursos (como scripts, folhas de estilo e imagens) são carregados, ajudando a otimizar os tempos de carregamento.
3. Depuração e Profiling:
- Durante o desenvolvimento,
PerformanceObserverpode ser usado para perfilar partes específicas do código, identificando funções lentas e possíveis gargalos.
4. Métricas de Desempenho Personalizadas:
- Os desenvolvedores podem criar métricas de desempenho personalizadas marcando e medindo pontos importantes na aplicação, permitindo uma análise de desempenho mais granular adaptada às necessidades específicas da aplicação.
Testes de Aplicação no Node.js
Até agora, aprendemos sobre a Performance API do Node.js, por que ela é importante, como funciona e como difere da função padrão Date.now().
Se você está construindo uma aplicação, você vai querer se concentrar em construir sua aplicação e deixar os testes para outros serviços. Bem, graças ao Apidog, você pode testar suas APIs e aplicações.
Apidog é uma ferramenta poderosa especificamente projetada para testes de API, incluindo testes de desempenho. Ela oferece soluções abrangentes para criar, gerenciar e testar APIs. O Apidog permite que você simule comportamentos de API, defina casos de teste e gere relatórios detalhados. Com sua interface intuitiva, você pode facilmente configurar testes de desempenho, analisar tempos de resposta e identificar gargalos de desempenho.
Conclusão
A Performance API do Node.js, incluindo ferramentas como performance.mark(), performance.measure() e PerformanceObserver, fornece aos desenvolvedores capacidades poderosas para monitorar e otimizar o desempenho da aplicação. Ao aproveitar essas ferramentas, você pode obter insights precisos sobre as características de desempenho de suas aplicações Node.js, identificar gargalos e implementar otimizações direcionadas para aumentar a eficiência e a experiência do usuário.
Além da Performance API, utilizar as melhores práticas de APIs/Aplicação, e testes de carga robustos e monitoramento pode aumentar significativamente o desempenho geral de suas aplicações. Esses esforços combinados garantem que suas aplicações Node.js funcionem sem problemas, escalem de forma eficaz e ofereçam uma experiência superior ao usuário, mantendo assim uma vantagem competitiva no mercado.
