Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Comment analyser les messages OpenTelemetry 0.7.0
Cette section fournit des informations pour vous aider à démarrer avec l'analyse de la version OpenTelemetry 0.7.0.
Tout d'abord, vous devez obtenir des liaisons spécifiques à la langue, qui vous permettent d'analyser les messages de la OpenTelemetry version 0.7.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](https://mvnrepository.com/artifact/io.opentelemetry/opentelemetry-proto/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'adresse[Générer vos classes](https://developers.google.com/protocol-buffers/docs/proto3#generating).
1. Installez le compilateur Protobuf en suivant les étapes indiquées dans [Télécharger les tampons de protocole](https://developers.google.com/protocol-buffers/docs/downloads).
1. Téléchargez les ProtoBuf définitions OpenTelemetry 0.7.0 dans la [version 0.7.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0).
1. Vérifiez que vous vous trouvez dans le dossier racine des ProtoBuf définitions OpenTelemetry 0.7.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](https://developers.google.com/protocol-buffers/docs/proto3#generating).
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 parse(InputStream inputStream) throws IOException {
List 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|pExportMetricsService...
------ --------------------------- ------ -----------------------
*/
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](https://developers.google.com/protocol-buffers/docs/downloads).
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.