Como analisar mensagens do OpenTelemetry 1.0.0

Esta seção fornece informações para ajudar você a começar a analisar o OpenTelemetry 1.0.0.

Primeiro, é necessário obter associações específicas de idioma que permitem analisar mensagens do OpenTelemetry 1.0.0 no idioma de sua preferência.

Para obter associações específicas de idioma

• As etapas dependem do idioma de sua preferência.

  • Para usar o Java, adicione a seguinte dependência Maven ao projeto Java: OpenTelemetry Java >> 0.14.1.

  • Para utilizar qualquer outro idioma, siga estas etapas:

    1. Verifique se seu idioma é compatível, conferindo a lista em Gerar suas classes.

    2. Instale o compilador Protobuf seguindo as etapas em Baixar buffers de protocolo.

    3. Faça o download das definições de buffers de protocolo (ProtoBuf) do OpenTelemetry 1.0.0 na página Release version 1.0.0.

    4. Confirme que você está na pasta raiz das definições de buffers de protocolo (ProtoBuf) do OpenTelemetry 1.0.0 baixadas. Depois, crie uma pasta src e execute o comando para gerar ligações específicas do idioma. Para obter mais informações, consulte Gerar suas classes.

       Veja a seguir um exemplo de como gerar associações Javascript.

       protoc --proto_path=./ --js_out=import_style=commonjs,binary:src \
       opentelemetry/proto/common/v1/common.proto \
       opentelemetry/proto/resource/v1/resource.proto \
       opentelemetry/proto/metrics/v1/metrics.proto \
       opentelemetry/proto/collector/metrics/v1/metrics_service.proto
       

A seção a seguir contém exemplos de como usar as vinculações específicas de idioma que você pode criar usando as instruções anteriores.

Java

package com.example;

import io.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class MyOpenTelemetryParser {

    public List<ExportMetricsServiceRequest> parse(InputStream inputStream) throws IOException {
        List<ExportMetricsServiceRequest> result = new ArrayList<>();

        ExportMetricsServiceRequest request;
        /* A Kinesis record can contain multiple `ExportMetricsServiceRequest`
           records, each of them starting with a header with an
           UnsignedVarInt32 indicating the record length in bytes:
            ------ --------------------------- ------ -----------------------
           |UINT32|ExportMetricsServiceRequest|UINT32|ExportMetricsService...
            ------ --------------------------- ------ -----------------------
         */
        while ((request = ExportMetricsServiceRequest.parseDelimitedFrom(inputStream)) != null) {
            // Do whatever we want with the parsed message
            result.add(request);
        }

        return result;
    }
}

Javascript

Este exemplo pressupõe que a pasta raiz com as ligações geradas seja ./

O argumento de dados da função parseRecord pode ser de um destes tipos:

• Uint8Array é o ideal

• Buffer ideal no nó

• Array.number inteiros de 8 bits

const pb = require('google-protobuf')
const pbMetrics =
    require('./opentelemetry/proto/collector/metrics/v1/metrics_service_pb')

function parseRecord(data) {
    const result = []

    // Loop until we've read all the data from the buffer
    while (data.length) {
        /* A Kinesis record can contain multiple `ExportMetricsServiceRequest`
           records, each of them starting with a header with an
           UnsignedVarInt32 indicating the record length in bytes:
            ------ --------------------------- ------ -----------------------
           |UINT32|ExportMetricsServiceRequest|UINT32|ExportMetricsService...
            ------ --------------------------- ------ -----------------------
         */
        const reader = new pb.BinaryReader(data)
        const messageLength = reader.decoder_.readUnsignedVarint32()
        const messageFrom = reader.decoder_.cursor_
        const messageTo = messageFrom + messageLength

        // Extract the current `ExportMetricsServiceRequest` message to parse
        const message = data.subarray(messageFrom, messageTo)

        // Parse the current message using the ProtoBuf library
        const parsed =
            pbMetrics.ExportMetricsServiceRequest.deserializeBinary(message)

        // Do whatever we want with the parsed message
        result.push(parsed.toObject())

        // Shrink the remaining buffer, removing the already parsed data
        data = data.subarray(messageTo)
    }

    return result
}

Python

É necessário ler os delimitadores var-int você mesmo ou usar os métodos internos _VarintBytes(size) e _DecodeVarint32(buffer, position). Estes retornam a posição no buffer logo após os bytes de tamanho. O lado de leitura constrói um novo buffer que está limitado a ler apenas os bytes da mensagem.

size = my_metric.ByteSize()
f.write(_VarintBytes(size))
f.write(my_metric.SerializeToString())
msg_len, new_pos = _DecodeVarint32(buf, 0)
msg_buf = buf[new_pos:new_pos+msg_len]
request = metrics_service_pb.ExportMetricsServiceRequest()
request.ParseFromString(msg_buf)

Go

Use Buffer.DecodeMessage().

C#

Use CodedInputStream. Essa classe é capaz de ler mensagens delimitadas por tamanho.

C++

As funções descritas em google/protobuf/util/delimited_message_util.h podem ler mensagens delimitadas por tamanho.

Outras linguagens

Para outros idiomas, consulte Baixar buffers de protocolo.

Ao implementar o analisador, considere que um registro do Kinesis pode conter vários mensagens de buffers de protocolo ExportMetricsServiceRequest, todas delas começando com um cabeçalho contendo UnsignedVarInt32, que indica o tamanho do registro em bytes.