Comment analyser les messages OpenTelemetry 1.0.0

Cette section fournit des informations pour vous aider à démarrer avec l'analyse de la OpenTelemetry version 1.0.0.

Tout d'abord, vous devez obtenir des liaisons spécifiques à la langue, qui vous permettent d'analyser les messages OpenTelemetry 1.0.0 dans votre langue préférée.

Pour obtenir des liaisons spécifiques à une langue

• Les étapes à suivre dépendent de votre langue préférée.

  • Pour utiliser Java, ajoutez la dépendance Maven suivante à votre projet Java : OpenTelemetry Java >> 0.14.1.

  • Pour utiliser une autre langue, procédez comme suit :

    1. Vérifiez que votre langue est prise en charge en consultant la liste à l'adresseGénérer vos classes.

    2. Installez le compilateur Protobuf en suivant les étapes indiquées dans Télécharger les tampons de protocole.

    3. Téléchargez les ProtoBuf définitions de la version OpenTelemetry 1.0.0 dans la version 1.0.0.

    4. Vérifiez que vous vous trouvez dans le dossier racine des ProtoBuf définitions OpenTelemetry 1.0.0 téléchargées. Créez ensuite un dossier src puis exécutez la commande pour générer des liaisons spécifiques à la langue. Pour de plus amples informations, veuillez consulter Générer vos classes.

       Voici un exemple qui montre comment générer des liaisons 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
       

La section suivante présente des exemples d'utilisation des liaisons spécifiques à la langue que vous pouvez créer à l'aide des instructions précédentes.

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

Cet exemple suppose que le dossier racine avec les liaisons générées est ./

L'argument de données de la fonction parseRecord peut avoir l'un des types suivants :

• Uint8Array c'est optimal

• Buffer optimal sous le nœud

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

Vous devez lire les délimiteurs var-int vous-même ou utilisez les méthodes internes _VarintBytes(size) et _DecodeVarint32(buffer, position). Ceux-ci retournent la position dans le tampon juste après les octets de taille. Le côté lecture construit un nouveau tampon qui est limité à la lecture uniquement des octets du message.

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

Utilisez Buffer.DecodeMessage().

C#

Utilisez CodedInputStream. Cette classe peut lire des messages délimités par la taille.

C++

Les fonctions décrites dans google/protobuf/util/delimited_message_util.h peuvent lire des messages délimités par la taille.

Autres langages

Pour d'autres langues, consultez Télécharger les tampons de protocole.

Lors de l'implémentation de l'analyseur, considérez qu'un registre Kinesis peut contenir plusieurs messages des tampons de protocole ExportMetricsServiceRequest, chacun d'entre eux commençant par un en-tête avec un objet UnsignedVarInt32 indiquant la longueur de l'enregistrement en octets.