# Descubra cómo se analizan los mensajes de OpenTelemetry 0.7.0
En esta sección se proporciona información que le ayudará a comenzar a analizar OpenTelemetry 0.7.0.
En primer lugar, debe obtener enlaces específicos de idioma, que le permiten analizar mensajes OpenTelemetry 0.7.0 en el idioma de su preferencia.
**Para obtener enlaces específicos de idioma**
+ Los pasos dependen del idioma que prefiera.
+ Para utilizar Java, agregue la siguiente dependencia de Maven a su proyecto de Java: [OpenTelemetry Java >> 0.14.1](https://mvnrepository.com/artifact/io.opentelemetry/opentelemetry-proto/0.14.1).
+ Para utilizar cualquier otro idioma, siga estos pasos:
1. Asegúrese de que su idioma es compatible; puede verificarlo en la lista en [Generating Your Classes](https://developers.google.com/protocol-buffers/docs/proto3#generating) (Generación de clases).
1. Instale el compilador Protobuf con los pasos que se indican en [Download Protocol Buffers](https://developers.google.com/protocol-buffers/docs/downloads) (Descargar búferes de protocolo).
1. Descargue las definiciones de OpenTelemetry 0.7.0 ProtoBuf en [v0.7.0 release](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0) (Versión v0.7.0).
1. Confirme que se encuentra en la carpeta raíz de las definiciones OpenTelemetry 0.7.0 ProtoBuf descargadas. Después, cree una carpeta de `src` y, a continuación, ejecute el comando para generar enlaces específicos de idioma. Para obtener más información, consulte [Generating Your Classes](https://developers.google.com/protocol-buffers/docs/proto3#generating) (Generación de clases).
A continuación se muestra un ejemplo de cómo se generan los enlaces de 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
```
En la siguiente sección se incluyen ejemplos de uso de enlaces específicos de idioma que se pueden crear mediante las instrucciones 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**
En este ejemplo se asume que la carpeta raíz con los enlaces generados es `./`
El argumento de datos de la función `parseRecord` puede tratarse de uno de los siguientes tipos:
+ `Uint8Array` es opcional.
+ `Buffer` óptimo debajo del nodo
+ `Array.{{number}}` enteros 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**
Debe leer los delimitadores `var-int` usted mismo o utilizar los métodos internos `_VarintBytes(size)` y `_DecodeVarint32(buffer, position)`. Estos devuelven la posición en el búfer justo después de los bytes. El lado de lectura construye un nuevo búfer que se limita a leer sólo los bytes del mensaje.
```
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**
Utilice `Buffer.DecodeMessage()`.
**C\#**
Utilice `CodedInputStream`. Esta clase puede leer mensajes delimitados por tamaño.
**C\+\+**
Las funciones descritas en `google/protobuf/util/delimited_message_util.h` pueden leer mensajes delimitados por tamaño.
**Otros idiomas**
Para ver otros idiomas, consulte [Download Protocol Buffers](https://developers.google.com/protocol-buffers/docs/downloads) (Descargar búferes de protocolo).
Al implementar el analizador, tenga en cuenta que un registro Kinesis puede contener varios mensajes de búferes de protocolo `ExportMetricsServiceRequest`, cada uno de ellos con un encabezado con un `UnsignedVarInt32` que indica la longitud de registro en bytes.