DEV Community: RaVi

Distributed Tracing com plugins do OpenTelemetry, Node e Jaeger

RaVi — Mon, 09 Jan 2023 00:49:24 +0000

No dia 30 de março foi anunciada a fase beta do OpenTelemetry. O objetivo do projeto é facilitar o rastreamento distribuído através de uma série de ferramentas integradas como descrito no meu primeiro artigo sobre o assunto. Entre as metas estabelecidas para o lançamento do beta estava a integração de plugins que permitem instrumentação automática das aplicações, diminuindo de forma significativa o trabalho necessário para implementação. Os repositórios das bibliotecas já funcionais e em desenvolvimento podem ser encontrados na página do projeto no github.

Esse artigo trás um exemplo de Distributed Tracing de aplicações Node usando http, Express e IORedis para simular o monitoramento de uma arquitetura de micro serviços usando a API javascript do OpenTelemetry e os plugins de instrumentação automática de cada módulo. Vamos explorar brevemente pedaços de código para ilustrar o funcionamento do sistema e o que é necessário ser feito para ter as informações de execução disponíveis no Jaeger como na imagem:

Visualização dos spans de um trace na interface do Jaeger

Nossa implementação de exemplo consiste em dois servidores, o primeiro simula uma API que serve de primeiro ponto de contato na comunicação e repassa as requisições para o segundo, que é responsável por buscar os dados necessários acessando o redis. Recomendo muito dar uma olhada no código completo aqui e para rodar basta fazer docker-compose up ou seguir as instruções para cada serviço. No compose temos os containers de cada serviço e o Jaeger que vai servir como backend e interface para análise dos spans coletados.

Como uma aplicação de exemplo, o funcionamento é bem simplificado. Ao acessar localhost:3000 pela primeira vez um resultado vazio é retornado.

Essa rota acessa o middleware e pede os valores para as keys key1, key2 e key3.

// api.js
...
const values = ['key1', 'key2', 'key3']

app.get('/', async (_, res) => {
  console.log('get /', middleware_url);
  const resultList = await Promise.all(
    values.map(v => httpRequest(middleware_url, 4000, '/' + v))
  )

  console.log({ resultList });
  res.status(200).send(resultList.toString());
})
...

Usamos a rota /set-values para popular esses valores:

// api.js
...
  app.get('/set-values', async (_, res) => {
    const testItens = [
      { key: 'key1', value: 'value1' },
      { key: 'key2', value: 'value2' },
      { key: 'key3', value: 'value3' },
    ]

    await Promise.all(
      testItens.map(i => httpRequest(middleware_url, 4000, `/set?key=${i.key}&value=${i.value}`))
    ).then((result) => {
      res.status(200).send(result.toString());
    })
  })
...

e agora ao acessar localhost:3000 obtemos os valores para as chaves solicitadas:

Se você rodou o código a partir do repositório completo e fez esses 3 passos já pode visualizar os traces gerados na interface do Jaeger em: http://localhost:16686 selecionando o Service api e clicando em find traces.

Isso é possível graças aos plugins do OpenTelemetry. Com a instrumentação automática não é preciso mudar cada parte do código para adicionar o tracing. Os plugins fazem patch dos módulos e escutam as chamadas internas adicionando a passagem de contexto onde é necessário.

No topo dos arquivos api.js e middleware.js você verá:

const { createTracer } = require('./tracer');
createTracer('api');

O tracer importa as bibliotecas do OpenTelemetry e inicializa o NodeTracerProvider que precisa ser definido antes do import dos módulos suportados. Aqui também é configurado o exporter do Jaeger.

// tracer.js
const opentelemetry = require('@opentelemetry/api');
const { NodeTracerProvider } = require('@opentelemetry/node');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');

const createTracer = (serviceName) => {
  const provider = new NodeTracerProvider();
  exporter = new JaegerExporter({
    serviceName,
    host: 'jaeger'
  });
  provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
  provider.register();

  return opentelemetry.trace.getTracer(serviceName)
}


module.exports = {
  createTracer,
}

O que é OpenTelemetry? Distributed Tracing - Observability numa arquitetura de micro serviços

RaVi — Mon, 18 May 2020 03:32:20 +0000

O Princípio de responsabilidade única, cunhado por Robert C. Martin, basicamente diz: "junte as coisas que mudam pelo mesmo motivo, e separe as coisas que mudam por motivos diferentes".

Uma arquitetura de micro serviços exerce muito bem esse princípio e traz uma série de benefícios na capacidade de desenvolver, manter e publicar de forma independente os diferentes componentes de um sistema. O aumento da granularidade traz também alguns pontos negativos e uma preocupação constante ao adotar micro serviços é o aumento da complexidade no monitoramento do sistema e na dificuldade de entender por que algo deu errado, identificar gargalos de performance e ter uma visão macro do funcionamento do sistema.

// Detect dark theme var iframe = document.getElementById('tweet-651897353889259520-906'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=651897353889259520&theme=dark" }

Distributed Tracing

É aqui que Distributed Tracing entra, como uma série de técnicas que tem como principal objetivo prover aos desenvolvedores uma maneira de rastrear requisições individuais enquanto elas "pulam" de árvore em arvore numa floresta de micro serviços. Em vez de monitorar entidades ou eventos isolados, Distributed Tracing nos permite acompanhar traces de cada componente envolvido. cada trace é composto de spans que registram detalhes da interação com um componente.

São possibilidades desbloqueadas ao adotar alguma forma de Distributed Tracing:

Saber exatamente o caminho percorrido para uma determinada solicitação.
Mensurar a latência de cada componente ao longo do caminho.
Identificar qual serviço gera uma falha ou um gargalo.

Conceitos chave de Distributed Tracing:

Trace: Registro de uma atividade através de um sistema distribuído. Uma árvore ou um Grafo acíclico dirigido de spans

Spans: Representam um segmento nomeado e contínuo de processamento em um trace. Tem relações causais ou de Pai-Filho com outros spans.

Spans e traces, fonte: Documentação do Jaeger

Span root: Primeiro span num trace. geralmente tem a duração exata ou aproximada de todo o trace. Na imagem, o span A é o span root.

Context propagation: Base do processo de Tracing. Como o rastro distribuído atravessa mais de um serviço, informações únicas de identificação são necessárias em todos os caminhos que a requisição pode tomar.

Tracer interface: Provê os meios para criar e interagir com spans.

OpenTracing, OpenCensus e, finalmente, OpenTelemetry

Até um passado não tão distante, dois projetos de instrumentação de Distributed Tracing competiam. O OpenCensus começou no Google como uma plataforma de Observability interna com participação da forte da Microsoft que começou a contribuir e ajudar a guiar o avanço do projeto logo após sua abertura para open source no GitHub. Já o OpenTracing, apoiado pela [Cloud Native Computing Foundation (CNCF)],(https://www.cncf.io/) consiste em uma especificação semântica que tem como meta a definição de uma API de tracing padronizada.

Reconhecendo a dificuldade de adoção da tecnologia trazida pela divisão da comunidade e pela falta de um padrão único de implementação, as lideranças dos dois projetos se uniram para criar o OpenTelemetry que entrou oficialmente em beta no dia 30 de março.

O projeto reúne os pontos fortes do OpenCensus e do OpenTracing para prover um conjunto único de APIs específicas de linguagens, SDKs, agentes e outros componentes que podem ser usados para coletar traces distribuídos, métricas e metadados relacionados nas aplicações. Como descrito no post de lançamento, muito da utilidade do OpenTelemetry vem da integração com bibliotecas HTTP e RPC e clientes de armazenamento, permitindo a captura de dados de observação das aplicações com esforço muito reduzido.

O lançamento do beta do OpenTelemetry é um passo importante para a popularização da prática de Distributed Tracing. Novas funcionalidades continuarão sendo adicionadas e agora com colaboradores de bibliotecas se adaptando as APIs do OpenTelemetry e usuários finais integrando OpenTelemetry aos seus serviços, o nível de maturidade da tecnologia só tende a crescer.

Para mais detalhes de como o OpenTelemetry funciona, com um exemplo de implementação, clique aqui.