Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# CloudWatch keluaran aliran metrik dalam format OpenTelemetry 1.0.0
**catatan**
Dengan format OpenTelemetry 1.0.0, atribut metrik dikodekan sebagai daftar `KeyValue` objek, bukan `StringKeyValue` tipe yang digunakan dalam format 0.7.0. Sebagai konsumen, ini merupakan satu-satunya perubahan besar yang terjadi antara format 0.7.0 dan 1.0.0. Pengurai yang dihasilkan dari file proto 0.7.0 tidak akan melakukan penguraian terhadap atribut-atribut metrik yang dikodekan dalam format 1.0.0. Hal yang sama berlaku secara terbalik, pengurai yang dihasilkan dari file proto 1.0.0 tidak akan melakukan penguraian terhadap atribut-atribut metrik yang dikodekan dalam format 0.7.0.
OpenTelemetry adalah kumpulan alat, APIs, dan SDKs. Anda dapat menggunakannya untuk instrumen, menghasilkan, mengumpulkan, dan mengekspor data telemetri (metrik, log, dan jejak) untuk analisis. OpenTelemetry adalah bagian dari Cloud Native Computing Foundation. Untuk informasi selengkapnya, lihat [OpenTelemetry](https://opentelemetry.io/).
Untuk informasi tentang spesifikasi OpenTelemetry 1.0.0 lengkap, lihat [Rilis versi](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v1.0.0) 1.0.0.
Catatan Kinesis dapat berisi satu atau lebih struktur `ExportMetricsServiceRequest` OpenTelemetry data. Setiap struktur data dimulai dengan header dengan sebuah `UnsignedVarInt32` yang mengindikasikan panjang catatan dalam Byte. Setiap `ExportMetricsServiceRequest` dapat berisikan data dari beberapa metrik sekaligus.
Berikut ini adalah representasi string dari pesan struktur `ExportMetricsServiceRequest` OpenTelemetry data. OpenTelemetry membuat serial protokol biner Google Protocol Buffers, dan ini tidak dapat dibaca manusia.
```
resource_metrics {
resource {
attributes {
key: "cloud.provider"
value {
string_value: "aws"
}
}
attributes {
key: "cloud.account.id"
value {
string_value: "123456789012"
}
}
attributes {
key: "cloud.region"
value {
string_value: "us-east-1"
}
}
attributes {
key: "aws.exporter.arn"
value {
string_value: "arn:aws:cloudwatch:us-east-1:123456789012:metric-stream/MyMetricStream"
}
}
}
scope_metrics {
metrics {
name: "amazonaws.com/AWS/DynamoDB/ConsumedReadCapacityUnits"
unit: "NoneTranslated"
summary {
data_points {
start_time_unix_nano: 60000000000
time_unix_nano: 120000000000
count: 1
sum: 1.0
quantile_values {
value: 1.0
}
quantile_values {
quantile: 0.95
value: 1.0
}
quantile_values {
quantile: 0.99
value: 1.0
}
quantile_values {
quantile: 1.0
value: 1.0
}
attributes {
key: "Namespace"
value {
string_value: "AWS/DynamoDB"
}
}
attributes {
key: "MetricName"
value {
string_value: "ConsumedReadCapacityUnits"
}
}
attributes {
key: "Dimensions"
value {
kvlist_value {
values {
key: "TableName"
value {
string_value: "MyTable"
}
}
}
}
}
}
data_points {
start_time_unix_nano: 70000000000
time_unix_nano: 130000000000
count: 2
sum: 5.0
quantile_values {
value: 2.0
}
quantile_values {
quantile: 1.0
value: 3.0
}
attributes {
key: "Namespace"
value {
string_value: "AWS/DynamoDB"
}
}
attributes {
key: "MetricName"
value {
string_value: "ConsumedReadCapacityUnits"
}
}
attributes {
key: "Dimensions"
value {
kvlist_value {
values {
key: "TableName"
value {
string_value: "MyTable"
}
}
}
}
}
}
}
}
}
}
```
**Objek tingkat atas untuk membuat serial data metrik OpenTelemetry **
`ExportMetricsServiceRequest`adalah pembungkus tingkat atas untuk membuat serial muatan eksportir. OpenTelemetry Itu berisikan satu atau beberapa `ResourceMetrics`.
```
message ExportMetricsServiceRequest {
// An array of ResourceMetrics.
// For data coming from a single resource this array will typically contain one
// element. Intermediary nodes (such as OpenTelemetry Collector) that receive
// data from multiple origins typically batch the data before forwarding further and
// in that case this array will contain multiple elements.
repeated opentelemetry.proto.metrics.v1.ResourceMetrics resource_metrics = 1;
}
```
`ResourceMetrics`adalah objek tingkat atas untuk mewakili MetricData objek.
```
// A collection of ScopeMetrics from a Resource.
message ResourceMetrics {
reserved 1000;
// The resource for the metrics in this message.
// If this field is not set then no resource info is known.
opentelemetry.proto.resource.v1.Resource resource = 1;
// A list of metrics that originate from a resource.
repeated ScopeMetrics scope_metrics = 2;
// This schema_url applies to the data in the "resource" field. It does not apply
// to the data in the "scope_metrics" field which have their own schema_url field.
string schema_url = 3;
}
```
**objek Sumber Daya**
Objek `Resource` adalah sebuah objek pasangan-nilai yang berisikan beberapa informasi tentang sumber daya yang dihasilkan metrik. Untuk metrik yang dibuat oleh AWS, struktur data yang berisikan Amazon Resource Name (ARN) dari sumber daya yang berkaitan dengan metrik, seperti instans EC2 atau bucket S3.
Objek `Resource` berisikan atribut yang disebut `attributes`, yang menyimpan daftar pasangan nilai-kunci.
+ `cloud.account.id` berisi ID akun
+ `cloud.region` berisi Wilayah
+ `aws.exporter.arn` berisi ARN stream metrik
+ `cloud.provider` selalu `aws`.
```
// Resource information.
message Resource {
// Set of attributes that describe the resource.
// Attribute keys MUST be unique (it is not allowed to have more than one
// attribute with the same key).
repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
// dropped_attributes_count is the number of dropped attributes. If the value is 0, then
// no attributes were dropped.
uint32 dropped_attributes_count = 2;
}
```
** ScopeMetrics Objeknya**
Bidang `scope` tidak akan diisi. Kami hanya akan mengisi bidang metrik yang kami ekspor.
```
// A collection of Metrics produced by an Scope.
message ScopeMetrics {
// The instrumentation scope information for the metrics in this message.
// Semantically when InstrumentationScope isn't set, it is equivalent with
// an empty instrumentation scope name (unknown).
opentelemetry.proto.common.v1.InstrumentationScope scope = 1;
// A list of metrics that originate from an instrumentation library.
repeated Metric metrics = 2;
// This schema_url applies to all metrics in the "metrics" field.
string schema_url = 3;
}
```
**Objek metrik**
Objek metrik berisikan beberapa metadata dan kolom data `Summary` yang berisi sebuah daftar `SummaryDataPoint`.
Untuk stream metrik, metadatanya adalah sebagai berikut:
+ `name` adalah `amazonaws.com/metric_namespace/metric_name`
+ `description` akan menjadi kosong
+ `unit` akan diisi dengan pemetaan unit datum metrik ke varian yang sensitif huruf besar-kecil dari kode Terpadu untuk Unit Ukur. Untuk informasi selengkapnya, silakan lihat [Terjemahan dengan format OpenTelemetry 1.0.0 di CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation-100.md) dan [Kode Terpadu Untuk Unit Ukur](https://ucum.org/ucum.html).
+ `type` adalah `SUMMARY`
```
message Metric {
reserved 4, 6, 8;
// name of the metric, including its DNS name prefix. It must be unique.
string name = 1;
// description of the metric, which can be used in documentation.
string description = 2;
// unit in which the metric value is reported. Follows the format
// described by http://unitsofmeasure.org/ucum.html.
string unit = 3;
// Data determines the aggregation type (if any) of the metric, what is the
// reported value type for the data points, as well as the relatationship to
// the time interval over which they are reported.
oneof data {
Gauge gauge = 5;
Sum sum = 7;
Histogram histogram = 9;
ExponentialHistogram exponential_histogram = 10;
Summary summary = 11;
}
}
message Summary {
repeated SummaryDataPoint data_points = 1;
}
```
** SummaryDataPoint Objeknya**
SummaryDataPoint Objek berisi nilai titik data tunggal dalam deret waktu dalam DoubleSummary metrik.
```
// SummaryDataPoint is a single data point in a timeseries that describes the
// time-varying values of a Summary metric.
message SummaryDataPoint {
reserved 1;
// The set of key/value pairs that uniquely identify the timeseries from
// where this point belongs. The list may be empty (may contain 0 elements).
// Attribute keys MUST be unique (it is not allowed to have more than one
// attribute with the same key).
repeated opentelemetry.proto.common.v1.KeyValue attributes = 7;
// StartTimeUnixNano is optional but strongly encouraged, see the
// the detailed comments above Metric.
//
// Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
// 1970.
fixed64 start_time_unix_nano = 2;
// TimeUnixNano is required, see the detailed comments above Metric.
//
// Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
// 1970.
fixed64 time_unix_nano = 3;
// count is the number of values in the population. Must be non-negative.
fixed64 count = 4;
// sum of the values in the population. If count is zero then this field
// must be zero.
//
// Note: Sum should only be filled out when measuring non-negative discrete
// events, and is assumed to be monotonic over the values of these events.
// Negative events *can* be recorded, but sum should not be filled out when
// doing so. This is specifically to enforce compatibility w/ OpenMetrics,
// see: https://github.com/OpenObservability/OpenMetrics/blob/main/specification/OpenMetrics.md#summary
double sum = 5;
// Represents the value at a given quantile of a distribution.
//
// To record Min and Max values following conventions are used:
// - The 1.0 quantile is equivalent to the maximum value observed.
// - The 0.0 quantile is equivalent to the minimum value observed.
//
// See the following issue for more context:
// https://github.com/open-telemetry/opentelemetry-proto/issues/125
message ValueAtQuantile {
// The quantile of a distribution. Must be in the interval
// [0.0, 1.0].
double quantile = 1;
// The value at the given quantile of a distribution.
//
// Quantile values must NOT be negative.
double value = 2;
}
// (Optional) list of values at different quantiles of the distribution calculated
// from the current snapshot. The quantiles must be strictly increasing.
repeated ValueAtQuantile quantile_values = 6;
// Flags that apply to this specific data point. See DataPointFlags
// for the available flags and their meaning.
uint32 flags = 8;
}
```
Untuk informasi selengkapnya, lihat [Terjemahan dengan format OpenTelemetry 1.0.0 di CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation-100.md).
# Terjemahan dengan format OpenTelemetry 1.0.0 di CloudWatch
CloudWatch melakukan beberapa transformasi untuk memasukkan CloudWatch data ke dalam OpenTelemetry format.
**Menerjemahkan namespace, nama metrik, dan dimensi**
Atribut ini adalah pasangan nilai-kunci yang dikodekan ke dalam pemetaan.
+ Satu atribut memiliki kunci `Namespace` dan nilainya adalah namespace dari metrik tersebut
+ Satu atribut memiliki kunci `MetricName` dan nilainya adalah nama dari metrik tersebut
+ Satu pasangan memiliki kunci `Dimensions` dan nilainya adalah sebuah daftar pasangan nilai-kunci tersarang. Setiap pasangan dalam daftar ini memetakan ke dimensi CloudWatch metrik, di mana kunci pasangan adalah nama dimensi dan nilainya adalah nilai dimensi.
**Menerjemahkan Rata-rata, Jumlah, SampleCount, Min dan Maks**
Titik data Ringkasan memungkinkan CloudWatch untuk mengekspor semua statistik ini menggunakan satu titik data.
+ `startTimeUnixNano`berisi CloudWatch `startTime`
+ `timeUnixNano`berisi CloudWatch `endTime`
+ `sum` berisi statistik Jumlah.
+ `count`berisi SampleCount statistik.
+ `quantile_values` berisi dua objek `valueAtQuantile.value`:
+ `valueAtQuantile.quantile = 0.0` dengan `valueAtQuantile.value = Min value`
+ `valueAtQuantile.quantile = 0.99` dengan `valueAtQuantile.value = p99 value`
+ `valueAtQuantile.quantile = 0.999` dengan `valueAtQuantile.value = p99.9 value`
+ `valueAtQuantile.quantile = 1.0` dengan `valueAtQuantile.value = Max value`
Sumber daya yang menggunakan aliran metrik dapat menghitung statistik Rata-rata sebagai **Jumlah/ SampleCount**.
**Menerjemahkan unit-unit**
CloudWatch unit dipetakan ke varian peka huruf besar/kecil dari kode Terpadu untuk Satuan Ukuran, seperti yang ditunjukkan pada tabel berikut. Untuk informasi selengkapnya, silakan lihat [Kode Terpadu Untuk Unit Ukur](https://ucum.org/ucum.html).
| CloudWatch | OpenTelemetry |
| --- | --- |
| Detik | d |
| Detik atau Detik | detik |
| Mikrodetik | µs |
| Milidetik | ms |
| Byte | Oleh |
| Kilobyte | kBy |
| Megabyte | MBy |
| Gigabyte | GBy |
| Terabyte | TBy |
| Bit | bit |
| Kilobit | kbit |
| Megabit | MBit |
| Gigabit | GBit |
| Terabit | TBit |
| Persen | % |
| Hitungan | \$1Count\$1 |
| Tidak ada | 1 |
Unit yang digabungkan dengan garis miring dipetakan dengan menerapkan OpenTelemetry konversi kedua unit. Misalnya, Bytes/Second dipetakan ke BY/s.
# Cara mengurai pesan OpenTelemetry 1.0.0
Bagian ini memberikan informasi untuk membantu Anda memulai dengan parsing OpenTelemetry 1.0.0.
Pertama, Anda harus mendapatkan binding khusus bahasa, yang memungkinkan Anda mengurai pesan OpenTelemetry 1.0.0 dalam bahasa pilihan Anda.
**Untuk mendapatkan ikatan bahasa tertentu**
+ Langkah-langkahnya tergantung pada bahasa pilihan Anda.
+ [Untuk menggunakan Java, tambahkan dependensi Maven berikut ke proyek Java Anda: Java >> 0.14.1OpenTelemetry .](https://mvnrepository.com/artifact/io.opentelemetry/opentelemetry-proto/0.14.1)
+ Untuk menggunakan bahasa lain, ikuti langkah-langkah ini:
1. Pastikan bahasa Anda didukung dengan memeriksa daftar di [Menghasilkan Kelas Anda](https://developers.google.com/protocol-buffers/docs/proto3#generating).
1. Instal alat kompilasi Protobuf dengan mengikuti langkah-langkah di [Unduh Buffer Protokol](https://developers.google.com/protocol-buffers/docs/downloads).
1. Unduh ProtoBuf definisi OpenTelemetry 1.0.0 di [Rilis versi](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v1.0.0) 1.0.0.
1. Konfirmasikan bahwa Anda berada di folder root dari definisi OpenTelemetry 1.0.0 ProtoBuf yang diunduh. Kemudian buatlah folder `src` lalu jalankan perintah untuk menghasilkan ikatan bahasa khusus. Untuk informasi selengkapnya, silakan lihat [Menghasilkan Kelas Anda](https://developers.google.com/protocol-buffers/docs/proto3#generating).
Berikut ini adalah contoh untuk cara menghasilkan ikatan 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
```
Bagian berikut mencakup contoh-contoh menggunakan ikatan bahasa khusus yang dapat Anda bangun dengan menggunakan petunjuk sebelumnya.
**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|ExportMetricsService...
------ --------------------------- ------ -----------------------
*/
while ((request = ExportMetricsServiceRequest.parseDelimitedFrom(inputStream)) != null) {
// Do whatever we want with the parsed message
result.add(request);
}
return result;
}
}
```
**Javascript**
Contoh ini mengasumsikan bahwa folder akar dengan ikatan yang dihasilkan adalah `./`
Argumen data dari fungsi `parseRecord` dapat menjadi salah satu dari jenis berikut:
+ `Uint8Array` ini adalah optimal
+ `Buffer` menjadi optimal di bawah simpul
+ `Array.number` adalah bilangan bulat 8-bit
```
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**
Anda harus membaca anti pembatas `var-int` oleh Anda sendiri atau gunakan metode internal `_VarintBytes(size)` dan `_DecodeVarint32(buffer, position)`. Hal ini akan mengembalikan posisi dalam buffer langsung menyusul ukuran bita. Bagian baca akan mengonstruksi buffer baru yang terbatas pada pembacaan byte pesan saja.
```
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)
```
**Kunjungi**
Gunakan `Buffer.DecodeMessage()`.
**C\$1**
Gunakan `CodedInputStream`. Kelas ini dapat membaca pesan dengan ukuran tak terbatas.
**C\$1\$1**
Fungsi yang dijelaskan dalam `google/protobuf/util/delimited_message_util.h` dapat membaca pesan yang dibatasi ukuran.
**Bahasa lain**
Untuk bahasa lain, silakan lihat [Unduh Protokol Buffer](https://developers.google.com/protocol-buffers/docs/downloads).
Saat menerapkan alat pengurai, pertimbangkan bahwa sebuah catatan Kinesis dapat berisikan beberapa pesan Protokol Buffer `ExportMetricsServiceRequest` , masing-masing dimulai dengan sebuah header dengan sebuah `UnsignedVarInt32` yang menunjukkan panjang catatan dalam bita.