# Como analisar mensagens OpenTelemetry 0.7.0
Esta seção fornece informações para ajudar você a começar a analisar o OpenTelemetry 0.7.0.
Primeiro, é necessário obter associações específicas de idioma, que permitem analisar mensagens do OpenTelemetry 0.7.0 no idioma de sua preferência.
**Para obter associações específicas de idioma**
+ As etapas dependem do idioma de sua preferência.
+ Para usar o Java, adicione a seguinte dependência Maven ao projeto Java: [OpenTelemetry Java >> 0.14.1](https://mvnrepository.com/artifact/io.opentelemetry/opentelemetry-proto/0.14.1).
+ Para utilizar qualquer outro idioma, siga estas etapas:
1. Verifique se seu idioma é compatível, conferindo a lista em [Gerar suas classes](https://developers.google.com/protocol-buffers/docs/proto3#generating).
1. Instale o compilador Protobuf seguindo as etapas em [Baixar buffers de protocolo](https://developers.google.com/protocol-buffers/docs/downloads).
1. Baixe as definições do OpenTelemetry 0.7.0 ProtoBuf em [Release v0.7.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0).
1. Confirme se você está na pasta-raiz das definições do OpenTelemetry 0.7.0 ProtoBuf. Depois, crie uma pasta `src` e execute o comando para gerar ligações específicas do idioma. Para obter mais informações, consulte [Gerar suas classes](https://developers.google.com/protocol-buffers/docs/proto3#generating).
Veja a seguir um exemplo de como gerar associações 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
```
A seção a seguir contém exemplos de como usar as vinculações específicas de idioma que você pode criar usando as instruções 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 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**
Este exemplo pressupõe que a pasta raiz com as ligações geradas seja `./`
O argumento de dados da função `parseRecord` pode ser de um destes tipos:
+ `Uint8Array` é o ideal
+ `Buffer` ideal no nó
+ `Array.{{number}}` inteiros 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**
É necessário ler os delimitadores `var-int` você mesmo ou usar os métodos internos `_VarintBytes(size)` e `_DecodeVarint32(buffer, position)`. Estes retornam a posição no buffer logo após os bytes de tamanho. O lado de leitura constrói um novo buffer que está limitado a ler apenas os bytes da mensagem.
```
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**
Use `Buffer.DecodeMessage()`.
**C\#**
Use `CodedInputStream`. Essa classe é capaz de ler mensagens delimitadas por tamanho.
**C\+\+**
As funções descritas em `google/protobuf/util/delimited_message_util.h` podem ler mensagens delimitadas por tamanho.
**Outras linguagens**
Para outros idiomas, consulte [Baixar buffers de protocolo](https://developers.google.com/protocol-buffers/docs/downloads).
Ao implementar o analisador, considere que um registro do Kinesis pode conter vários mensagens de buffers de protocolo `ExportMetricsServiceRequest`, todas delas começando com um cabeçalho contendo `UnsignedVarInt32`, que indica o tamanho do registro em bytes.