Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Wie analysiert man 0.7.0-Nachrichten OpenTelemetry
Dieser Abschnitt enthält Informationen, die Ihnen den Einstieg in das OpenTelemetry Parsen von 0.7.0 erleichtern sollen.
Zunächst sollten Sie sich sprachspezifische Bindungen besorgen, mit denen Sie OpenTelemetry 0.7.0-Nachrichten in Ihrer bevorzugten Sprache analysieren können.
**So erhalten Sie sprachspezifische Bindungen**
+ Die Schritte hängen von Ihrer bevorzugten Sprache ab.
+ [Um Java zu verwenden, fügen Sie Ihrem Java-Projekt die folgende Maven-Abhängigkeit hinzu: Java >> 0.14.1. OpenTelemetry ](https://mvnrepository.com/artifact/io.opentelemetry/opentelemetry-proto/0.14.1)
+ Gehen Sie folgendermaßen vor, um eine andere Sprache zu verwenden:
1. Stellen Sie sicher, dass Ihre Sprache unterstützt wird, indem Sie die Liste unter [Generieren Ihrer Klassen](https://developers.google.com/protocol-buffers/docs/proto3#generating) überprüfen.
1. Installieren Sie den Protobuf-Compiler, indem Sie die Schritte unter [Protokollpuffer herunterladen](https://developers.google.com/protocol-buffers/docs/downloads) befolgen.
1. [Laden Sie die OpenTelemetry ProtoBuf 0.7.0-Definitionen in Version v0.7.0 herunter.](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0)
1. Vergewissern Sie sich, dass Sie sich im Stammordner der heruntergeladenen OpenTelemetry 0.7.0-Definitionen befinden. ProtoBuf Dann erstellen Sie einen `src`-Ordner und führen Sie den Befehl aus, um sprachspezifische Bindungen zu generieren. Weitere Informationen finden Sie unter [Generieren Ihrer Klassen](https://developers.google.com/protocol-buffers/docs/proto3#generating).
Nachfolgend finden Sie ein Beispiel für das Generieren von Javascript-Bindungen.
```
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
```
Der folgende Abschnitt enthält Beispiele für die Verwendung der sprachspezifischen Bindungen, die Sie mit den vorherigen Anweisungen erstellen können.
**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**
In diesem Beispiel wird davon ausgegangen, dass der Stammordner mit den generierten Bindungen `./` ist.
Das Datenargument der Funktion `parseRecord` kann einer der folgenden Typen sein:
+ `Uint8Array` dies ist optimal.
+ `Buffer` optimal unter Knoten
+ `Array.{{number}}` 8-Bit-Ganzzahlen
```
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**
Sie müssen die `var-int`-Trennzeichen selbst lesen oder die internen Methoden `_VarintBytes(size)` und `_DecodeVarint32(buffer, position)` verwenden. Diese geben die Position im Puffer direkt nach den Größenbytes zurück. Die Leseseite erstellt einen neuen Puffer, der darauf beschränkt ist, nur die Bytes der Nachricht zu lesen.
```
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**
Verwenden Sie `Buffer.DecodeMessage()`.
**C\#**
Verwenden Sie `CodedInputStream`. Diese Klasse kann Nachrichten mit größenbegrenztem Abstand lesen.
**C\+\+**
Die in `google/protobuf/util/delimited_message_util.h` beschriebenen Funktionen können größenbegrenzte Nachrichten lesen.
**Andere Sprachen**
Informationen zu anderen Sprachen finden Sie unter [Herunterladen von Protokollpuffern](https://developers.google.com/protocol-buffers/docs/downloads).
Bedenken Sie bei der Implementierung des Parsers, dass ein Kinesis-Datensatz mehrere `ExportMetricsServiceRequest` Protokollpuffer-Nachrichten enthalten kann, von denen jede mit einem Header mit einem `UnsignedVarInt32` beginnt, das die Datensatzlänge in Byte angibt.