O Managed Service for OpenTelemetry utiliza o modelo de dados OpenTracing para oferecer rastreamento distribuído em arquiteturas de microsserviços. Este tópico aborda traces, spans, o modelo de dados e os métodos de relatório de dados.
O OpenTracing é o predecessor do OpenTelemetry. O Managed Service for OpenTelemetry oferece suporte ao modelo de dados OpenTracing descrito aqui. Para consultar o padrão OpenTelemetry, acesse a documentação do OpenTelemetry.
Conceitos principais
|
Conceito |
Descrição |
|
Rastreamento distribuído |
Método para acompanhar requisições à medida que trafegam por múltiplos serviços em um sistema distribuído. |
|
Trace |
Registro de ponta a ponta de uma transação ou processo em um sistema distribuído. Um trace é um grafo acíclico direcionado (DAG) composto por spans. |
|
Span |
Unidade de trabalho nomeada e temporizada dentro de um trace. |
|
SpanContext |
Metadados que identificam um span (trace ID, span ID) e transportam baggage items entre limites de processos. |
|
Reference |
Relação causal entre dois spans. O OpenTracing define dois tipos: ChildOf e FollowsFrom. |
|
Tracer |
Interface responsável por criar spans e propagar contexto entre serviços. |
A importância do rastreamento distribuído
Aplicações modernas adotam arquiteturas de microsserviços, nas quais as equipes utilizam práticas como desenvolvimento ágil e integração contínua. A arquitetura de sistemas evoluiu de softwares monolíticos de grande porte para modelos baseados em microsserviços, em que uma única requisição pode atravessar dezenas de serviços. Esses serviços podem ser escritos em linguagens diferentes, mantidos por equipes distintas e implantados em vários servidores. Quando ocorre uma falha em um serviço, diversas aplicações podem apresentar exceções. Sem visibilidade de ponta a ponta, torna-se impraticável identificar a causa raiz.
Um sistema de rastreamento distribuído registra o caminho completo de execução e o tempo de cada requisição, incluindo o processo de execução e o consumo de tempo de chamadas de método remoto. Essa visibilidade é essencial para solucionar problemas do sistema e otimizar seu desempenho.
Traces
Um trace representa o processo de execução de uma transação ou fluxo em um sistema distribuído. No padrão OpenTracing, o trace é um grafo acíclico direcionado (DAG) formado por múltiplos spans. Cada span corresponde a um segmento nomeado e temporizado executado continuamente dentro do trace.
Por exemplo, uma requisição de cliente pode passar por um balanceador de carga, um serviço de autenticação e um serviço de faturamento antes de alcançar o recurso de destino e retornar uma resposta.
Sistemas de rastreamento geralmente exibem esse fluxo como uma linha do tempo, em que cada linha representa um span e o eixo horizontal indica o tempo.
Spans
O span representa uma unidade individual de trabalho dentro de um trace. Cada span contém os seguintes dados:
|
Campo |
Descrição |
|
Nome da operação |
Rótulo legível que descreve o trabalho realizado (também chamado de nome do span). |
|
Timestamp de início |
Momento em que a operação começou. |
|
Timestamp de término |
Momento em que a operação foi concluída. |
|
Tags |
Pares chave-valor que anotam o span. As chaves são strings; os valores podem ser strings, booleanos ou números. |
|
Logs |
Pares chave-valor com timestamp que registram eventos durante o ciclo de vida do span. As chaves são strings; os valores podem ser de qualquer tipo. |
|
SpanContext |
Metadados para identificar o span e propagá-lo entre limites de processos. Consulte SpanContext. |
|
References |
Vínculos com outros spans que estabelecem relações de pai-filho ou sequenciais. Podem incluir zero ou múltiplos spans relacionados. |
Relacionamentos entre spans
O OpenTracing define dois tipos de referências entre spans:
ChildOf: Relação de pai e filho. Por exemplo, o Span C é um nó filho do Span A.
FollowsFrom: Relação sequencial. Por exemplo, o Span G é chamado após o Span F.
O diagrama a seguir mostra oito spans e seus relacionamentos dentro de um único trace:
Causal relationships among spans in a single trace
[Span A] <-- root span
|
+------+------+
| |
[Span B] [Span C] (ChildOf: Span C is a child of Span A)
| |
[Span D] +---+-------+
| |
[Span E] [Span F] >>> [Span G] >>> [Span H]
^
|
(FollowsFrom: Span G follows Span F)O mesmo trace exibido como uma linha do tempo:
Time relationships among spans in a single trace
--|-------|-------|-------|-------|-------|-------|-------|-> time
[Span A..........................................................]
[Span B...................................................]
[Span D................................................]
[Span C...............................................]
[Span E.......] [Span F..] [Span G..] [Span H..]SpanContext
O SpanContext transporta os metadados necessários para identificar um span e propagá-lo entre limites de processos. Ele contém:
Trace ID: Identificador exclusivo para todo o trace.
Span ID: Identificador exclusivo para o span individual.
Baggage items: Pares chave-valor que acompanham o trace pelos limites de serviços. Esses pares chave-valor também devem ser transmitidos entre limites de processos.
Interface Tracer
O Tracer é o ponto de entrada para criar spans e propagar contexto entre serviços. Ele fornece o método StartSpan para criar um span, o método Extract para extrair contexto e o método Inject para injetar contexto.
Criar um span
Use o método StartSpan para criar e iniciar um novo span. O método retorna um span com o nome da operação e as opções especificadas.
// Method signature:
// StartSpan(operationName string, opts ...StartSpanOption) Span
// Create a root span (no parent).
sp := tracer.StartSpan("GetFeed")
// Create a child span.
sp := tracer.StartSpan(
"GetFeed",
opentracing.ChildOf(parentSpan.Context()),
)Propagar contexto entre serviços
Para transmitir o contexto de trace entre serviços, o Tracer oferece dois métodos complementares:
-
Inject: Serializa um SpanContext (incluindo trace ID, span ID e baggage items) em um carrier (como cabeçalhos HTTP) antes de enviar uma requisição para outro serviço.
// Method signature: // Inject(sm SpanContext, format interface{}, carrier interface{}) error carrier := opentracing.HTTPHeadersCarrier(httpReq.Header) err := tracer.Inject( span.Context(), opentracing.HTTPHeaders, carrier, ) -
Extract: Desserializa um SpanContext (incluindo trace ID, span ID e baggage items) de um carrier ao receber uma requisição de outro serviço.
// Method signature: // Extract(format interface{}, carrier interface{}) (SpanContext, error) carrier := opentracing.HTTPHeadersCarrier(httpReq.Header) clientContext, err := tracer.Extract( opentracing.HTTPHeaders, carrier, )
Juntos, Inject e Extract permitem o rastreamento de ponta a ponta através de limites de processos e redes.
Relatório de dados
O Managed Service for OpenTelemetry oferece suporte a dois métodos para relatar dados de trace:
Relatório direto
A aplicação envia dados de trace diretamente para o backend de rastreamento, sem intermediários.
Relatório via agente
A aplicação envia dados de trace para um agente local (como o Jaeger Agent), que encaminha os dados para o backend de rastreamento.
