Come analizzare i messaggi 1.0.0 OpenTelemetry

Questa sezione fornisce informazioni per aiutarti a iniziare con l'analisi della 1.0.0. OpenTelemetry

Innanzitutto, dovresti ottenere associazioni specifiche per la lingua, che ti consentano di analizzare i messaggi 1.0.0 nella tua lingua preferita. OpenTelemetry

Per ottenere associazioni specifiche della lingua

• I passaggi dipendono dalla lingua preferita.

  • Per usare Java, aggiungi la seguente dipendenza Maven al tuo progetto Java: Java >> 0.14.1. OpenTelemetry

  • Per utilizzare qualsiasi altra lingua, procedi come segue:

    1. Assicurati che la lingua in uso sia supportata controllando l'elenco in Generating Your Classes (Generazione delle classi).

    2. Installa il compilatore Protobuf seguendo i passaggi descritti in Download Protocol Buffers (Scarica buffer protocolli).

    3. Scarica le definizioni OpenTelemetry 0.7.0 nella versione di rilascio 1.0.0 ProtoBuf .

    4. Verificate di trovarvi nella cartella principale delle definizioni 0.7.0 scaricate. OpenTelemetry ProtoBuf Quindi crea un cartella src e quindi esegui il comando per generare associazioni specifiche della lingua. Per ulteriori informazioni, consulta Generating Your Classes.

       Di seguito è riportato un esempio di come generare associazioni 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
       

Nella sezione seguente sono inclusi esempi di utilizzo delle associazioni specifiche della lingua che puoi creare utilizzando le istruzioni precedenti.

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

Questo esempio presuppone che la cartella principale con le associazioni generate sia ./

L'argomento dati della funzione parseRecord può essere uno dei seguenti tipi:

• Uint8Array è ottimale

• Buffer ottimale sotto il nodo

• Array.number numero intero a 8 bit

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

È necessario leggere i delimitatori var-int in autonomia o utilizzare i metodi interni _VarintBytes(size) e _DecodeVarint32(buffer, position). Questi restituiscono la posizione nel buffer subito dopo i byte di dimensione. Il lato lettura costruisce un nuovo buffer che è limitato alla lettura solo dei byte del messaggio.

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

Utilizza Buffer.DecodeMessage().

C#

Utilizza CodedInputStream. Questa classe può leggere messaggi delimitati da dimensioni.

C++

Le funzioni descritte in google/protobuf/util/delimited_message_util.h possono leggere messaggi delimitati dalle dimensioni.

Altre lingue

Per le altre lingue, consulta Download Protocol Buffers.

Nell'implementare il parser, considera che un record Kinesis può contenere più messaggi di buffer di protocollo ExportMetricsServiceRequest, ognuno dei quali inizia con un'intestazione con un UnsignedVarInt32 che indica la lunghezza del record in byte.