Descubra cómo se analizan los mensajes de OpenTelemetry 1.0.0

En esta sección se proporciona información que lo ayudará a comenzar a analizar OpenTelemetry 1.0.0.

En primer lugar, debe obtener enlaces específicos de idioma, que le permiten analizar mensajes de OpenTelemetry 1.0.0 en el idioma de su preferencia.

Para obtener enlaces específicos de idioma

• Los pasos dependen del idioma que prefiera.

  • Para utilizar Java, agregue la siguiente dependencia de Maven a su proyecto de Java: OpenTelemetry Java >> 0.14.1.

  • Para utilizar cualquier otro idioma, siga estos pasos:

    1. Asegúrese de que su idioma es compatible; puede verificarlo en la lista en Generating Your Classes (Generación de clases).

    2. Instale el compilador Protobuf con los pasos que se indican en Download Protocol Buffers (Descargar búferes de protocolo).

    3. Descargue las definiciones de OpenTelemetry 1.0.0 ProtoBuf en la versión de lanzamiento 1.0.0.

    4. Confirme que se encuentra en la carpeta raíz de las definiciones de OpenTelemetry 1.0.0 ProtoBuf descargadas. Después, cree una carpeta de src y, a continuación, ejecute el comando para generar enlaces específicos de idioma. Para obtener más información, consulte Generating Your Classes (Generación de clases).

       A continuación se muestra un ejemplo de cómo se generan los enlaces de 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
       

En la siguiente sección se incluyen ejemplos de uso de enlaces específicos de idioma que se pueden crear mediante las instrucciones 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

En este ejemplo se asume que la carpeta raíz con los enlaces generados es ./

El argumento de datos de la función parseRecord puede tratarse de uno de los siguientes tipos:

• Uint8Array es opcional.

• Buffer óptimo debajo del nodo

• Array.number enteros 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

Debe leer los delimitadores var-int usted mismo o utilizar los métodos internos _VarintBytes(size) y _DecodeVarint32(buffer, position). Estos devuelven la posición en el búfer justo después de los bytes. El lado de lectura construye un nuevo búfer que se limita a leer sólo los bytes del mensaje.

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

Utilice Buffer.DecodeMessage().

C#

Utilice CodedInputStream. Esta clase puede leer mensajes delimitados por tamaño.

C++

Las funciones descritas en google/protobuf/util/delimited_message_util.h pueden leer mensajes delimitados por tamaño.

Otros idiomas

Para ver otros idiomas, consulte Download Protocol Buffers (Descargar búferes de protocolo).

Al implementar el analizador, tenga en cuenta que un registro Kinesis puede contener varios mensajes de búferes de protocolo ExportMetricsServiceRequest, cada uno de ellos con un encabezado con un UnsignedVarInt32 que indica la longitud de registro en bytes.