Atualize os monitores de API com script para o Node.js 22

Estamos apresentando nosso mais recente runtime de monitor de API com script, com a versão Latest do Node.js (atualmente Node.js 22). O runtime Latest usa automaticamente a versão mais recente do Node.js suportada pela New Relic, garantindo que seus monitores de API sejam executados em um ambiente que atenda aos padrões modernos do Node.js, proporcionando maior segurança, estabilidade e desempenho.

Ação necessária: impacto da atualização do Node.js 22

Como parte da atualização do Node.js 16 para o Node.js 22, o runtime é mais rigoroso em relação aos ciclos de vida dos processos. Se seus scripts de monitor contiverem manipuladores abertos não tratados (como promises não resolvidas, temporizadores pendentes ou conexões de rede não fechadas), seus monitores falharão.

Para resolver isso: Valide seus scripts de monitor no runtime Latest para garantir que todos os handles sejam fechados corretamente antes que o script termine de ser executado. As validações com falha aparecem na UI de Runtime Upgrades. Consulte Solucionar erros de atualização de runtime.

Quem é afetado

A New Relic gerencia automaticamente o processo de atualização para:

• Monitores de API com script em localizações públicas
• Monitores de API com script em localizações públicas e privadas (híbrido)

A New Relic aplica validação e atualização automatizadas a todas as configurações de local.

O que é o Mais recente?

A opção de runtime Latest no dropdown de criação/atualização do monitor usa automaticamente a versão mais recente do Node.js suportada pela New Relic. Em vez de fixar em uma versão específica do Node.js (como Node.js 16 ou Node.js 20), Latest garante que seus monitores sempre sejam executados na versão mais recente disponível do Node.js com os últimos recursos, melhorias de desempenho e atualizações de segurança.

Atualizar monitores via NerdGraph

Para atualizar os runtimes do seu monitor programaticamente, use a mutação do NerdGraph abaixo. Você precisa do GUID da entidade do seu monitor (disponível nas configurações do monitor).

Monitor de API com script

mutation {
  syntheticsUpdateScriptApiMonitor(
    guid: "YOUR_MONITOR_GUID"
    monitor: {
      runtime: { runtimeType: "NODE_API", runtimeTypeVersion: "LATEST" }
    }
  ) {
    errors {
      description
      type
    }
  }
}

O processo de atualização automatizado

Para garantir uma transição tranquila para o runtime mais recente do Node.js, a New Relic testa proativamente seus monitores existentes. O processo inclui:

Solução de problemas de atualização

O problema mais comum ao atualizar para o Node.js 22 são os manipuladores abertos não tratados, incluindo promises não resolvidas, temporizadores pendentes, conexões não fechadas e conexões HTTP/HTTPS. Para soluções detalhadas e exemplos de código para cada tipo de problema, consulte Solucionar erros de atualização de runtime.

Alterações de ruptura do Node.js 22

Além do gerenciamento mais rigoroso de handles abertos, o Node.js 22 inclui outras alterações das quais você deve estar ciente:

Suporte a módulos atualizado

• Módulos ES: Melhor suporte para módulos ES, mas certifique-se de que suas importações estejam devidamente configuradas
• CommonJS: os módulos CommonJS ainda funcionam, mas podem ter uma validação mais rigorosa

APIs descontinuadas

Algumas APIs descontinuadas em versões anteriores do Node.js foram removidas no Node.js 22. Verifique o changelog do Node.js 22 para obter detalhes sobre os recursos removidos.

Melhorias de desempenho

O Node.js 22 inclui melhorias de desempenho que podem afetar testes sensíveis ao tempo. Considere revisar os tempos limite se seus monitores dependerem de comportamento específico de tempo.

Práticas recomendadas para o Node.js 22

Para garantir que seus monitores de API com script funcionem sem problemas com o Node.js 22:

1. Use async/await: Converta o código baseado em retorno de chamada para async/await para um melhor tratamento de erros.
2. Limpe os recursos: sempre feche as conexões, limpe os temporizadores e remova os ouvintes de eventos.
3. Trate todas as promises: nunca crie uma promise sem aguardá-la ou tratar seu resultado.
4. Defina tempos limites apropriados: Use tempos limites razoáveis para chamadas de API para evitar travamentos.
5. Teste localmente: Teste seus scripts localmente com o Node.js 22 antes de atualizar os monitores de produção.

Exemplo: Monitor de API completo

const assert = require('assert');
const $http = require('request');
const { promisify } = require('util');

// Promisify request methods
const httpGet = promisify($http.get);
const httpPost = promisify($http.post);

async function runAPITest() {
  try {
    // 1. Test GET endpoint
    console.log('Testing GET endpoint...');
    const getResponse = await httpGet('https://api.example.com/users');
    assert.equal(getResponse.statusCode, 200, 'GET request failed');

    // 2. Parse and validate response
    const users = JSON.parse(getResponse.body);
    assert(Array.isArray(users), 'Response is not an array');
    assert(users.length > 0, 'No users returned');

    // 3. Test POST endpoint
    console.log('Testing POST endpoint...');
    const postResponse = await httpPost({
      url: 'https://api.example.com/users',
      json: true,
      body: {
        name: 'Test User',
        email: 'test@example.com'
      }
    });
    assert.equal(postResponse.statusCode, 201, 'POST request failed');

    console.log('All tests passed!');
  } catch (error) {
    console.error('Test failed:', error.message);
    throw error; // Fail the monitor
  }
}

// Run the test
await runAPITest();

Perguntas frequentes

Quais tipos de monitores são afetados? Monitores de API com script. Os monitores de browser com script são afetados separadamente — veja Atualize os monitores sintéticos para a versão mais recente do Chrome e o Node.js 22. Monitores de navegador simples e monitores de ping não são afetados.

Posso testar meus scripts localmente antes de atualizar? Sim. Instale o Node.js 22 localmente e teste seus scripts de monitoramento para identificar problemas antes da atualização.

Posso fazer rollback se meu monitor falhar após a atualização? Sim. Você pode alterar a versão do runtime de volta nas configurações do monitor ou via NerdGraph.

Quando meus monitores serão atualizados automaticamente? A New Relic realiza a validação primeiro. Se a validação for bem-sucedida, a New Relic atualiza automaticamente os monitores. Se a validação falhar, você verá a falha na UI de Runtime Upgrades e deverá corrigir e atualizar manualmente.

Precisa de ajuda?

Se você encontrar problemas durante o processo de atualização:

1. Verifique a interface de Runtime Upgrades no seu Nerdlet do Sintéticos para obter mensagens de erro específicas.
2. Revise seus scripts de monitoramento em busca de promises não tratadas e conexões abertas.
3. Teste seus scripts localmente com o Node.js 22 antes de atualizar.
4. Entre em contato com o Suporte da New Relic para obter assistência na resolução de problemas de falhas de validação.

Documentação relacionada:

• Escreva testes da API Sintético
• Importar módulos Node.js
• Ambiente de execução de monitor com script
• Interface de atualização de runtime
• Solucionar erros de atualização em tempo de execução