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.
# CloudWatch metrische Stream-Ausgabe im OpenTelemetry 0.7.0-Format
OpenTelemetry ist eine Sammlung von Tools, APIs, und SDKs. Sie können damit Telemetriedaten (Metriken, Protokolle und Traces) für Analysen instrumentieren, generieren, sammeln und exportieren. OpenTelemetry ist Teil der Cloud Native Computing Foundation. Weitere Informationen finden Sie unter [OpenTelemetry](https://opentelemetry.io/).
Informationen zur vollständigen OpenTelemetry 0.7.0-Spezifikation finden Sie in der Version [v0.7.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0).
Ein Kinesis-Datensatz kann eine oder mehrere `ExportMetricsServiceRequest` OpenTelemetry Datenstrukturen enthalten. Jede Datenstruktur beginnt mit einem Header mit einem `UnsignedVarInt32`, das die Datensatzlänge in Byte angibt. Jede `ExportMetricsServiceRequest` kann Daten von mehreren Metriken gleichzeitig enthalten.
Das Folgende ist eine Zeichenkettendarstellung der Botschaft der `ExportMetricsServiceRequest` OpenTelemetry Datenstruktur. OpenTelemetry serialisiert das Binärprotokoll von Google Protocol Buffers, und dieses ist nicht für Menschen lesbar.
```
resource_metrics {
resource {
attributes {
key: "cloud.provider"
value {
string_value: "aws"
}
}
attributes {
key: "cloud.account.id"
value {
string_value: "2345678901"
}
}
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"
}
}
}
instrumentation_library_metrics {
metrics {
name: "amazonaws.com/AWS/DynamoDB/ConsumedReadCapacityUnits"
unit: "1"
double_summary {
data_points {
labels {
key: "Namespace"
value: "AWS/DynamoDB"
}
labels {
key: "MetricName"
value: "ConsumedReadCapacityUnits"
}
labels {
key: "TableName"
value: "MyTable"
}
start_time_unix_nano: 1604948400000000000
time_unix_nano: 1604948460000000000
count: 1
sum: 1.0
quantile_values {
quantile: 0.0
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
}
}
data_points {
labels {
key: "Namespace"
value: "AWS/DynamoDB"
}
labels {
key: "MetricName"
value: "ConsumedReadCapacityUnits"
}
labels {
key: "TableName"
value: "MyTable"
}
start_time_unix_nano: 1604948460000000000
time_unix_nano: 1604948520000000000
count: 2
sum: 5.0
quantile_values {
quantile: 0.0
value: 2.0
}
quantile_values {
quantile: 1.0
value: 3.0
}
}
}
}
}
}
```
**Objekt der obersten Ebene zur Serialisierung von Metrikdaten OpenTelemetry **
`ExportMetricsServiceRequest`ist der Wrapper der obersten Ebene zum Serialisieren einer Export-Payload. OpenTelemetry Es enthält eine oder mehrere `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`ist das Objekt der obersten Ebene zur Darstellung von Objekten. MetricData
```
// A collection of InstrumentationLibraryMetrics from a Resource.
message ResourceMetrics {
// 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 InstrumentationLibraryMetrics instrumentation_library_metrics = 2;
}
```
**Ressourcenobjekt**
Ein `Resource`-Objekt ist ein Wertpaarobjekt, das Informationen über die Ressource enthält, die die Metriken generiert hat. Bei Metriken, die von AWS erstellt wurden, enthält die Datenstruktur den Amazon-Ressourcennamen (ARN) der Ressource, die sich auf die Metrik bezieht, z. B. eine EC2-Instance oder ein S3 Bucket.
Das `Resource`-Objekt enthält ein Attribut namens `attributes`, das eine Liste von Schlüssel-Wert-Paaren speichert.
+ `cloud.account.id` enthält die Konto-ID
+ `cloud.region` enthält die Region
+ `aws.exporter.arn` enthält den Metrik-Stream-ARN
+ `cloud.provider` ist immer `aws`.
```
// Resource information.
message Resource {
// Set of labels that describe the resource.
repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
// dropped_attributes_count is the number of dropped attributes. If the value is 0,
// no attributes were dropped.
uint32 dropped_attributes_count = 2;
}
```
**Das Objekt InstrumentationLibraryMetrics **
Das Feld instrumentation\$1library wird nicht ausgefüllt. Wir füllen nur das Metrikfeld aus, das wir exportieren.
```
// A collection of Metrics produced by an InstrumentationLibrary.
message InstrumentationLibraryMetrics {
// The instrumentation library information for the metrics in this message.
// If this field is not set then no library info is known.
opentelemetry.proto.common.v1.InstrumentationLibrary instrumentation_library = 1;
// A list of metrics that originate from an instrumentation library.
repeated Metric metrics = 2;
}
```
**Metrikobjekt**
Das Metrikobjekt enthält ein `DoubleSummary`-Datenfeld, das eine Liste von `DoubleSummaryDataPoint` enthält.
```
message Metric {
// 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;
oneof data {
IntGauge int_gauge = 4;
DoubleGauge double_gauge = 5;
IntSum int_sum = 6;
DoubleSum double_sum = 7;
IntHistogram int_histogram = 8;
DoubleHistogram double_histogram = 9;
DoubleSummary double_summary = 11;
}
}
message DoubleSummary {
repeated DoubleSummaryDataPoint data_points = 1;
}
```
**Das MetricDescriptor Objekt**
Das MetricDescriptor Objekt enthält Metadaten. Weitere Informationen finden Sie unter [metrics.proto](https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/metrics/v1/metrics.proto#L110) on. GitHub
Für metrische Streams MetricDescriptor hat der den folgenden Inhalt:
+ `name` wird `amazonaws.com/metric_namespace/metric_name` sein.
+ `description` wird leer sein.
+ `unit` wird gefüllt, indem die Einheit des metrischen Datums auf die Variante des einheitlichen Codes für Maßeinheiten, bei der die Groß-/Kleinschreibung beachtet wird, abgebildet wird. Weitere Informationen finden Sie unter [Übersetzungen im Format OpenTelemetry 0.7.0 in CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation.md) und [Der einheitliche Code für Maßeinheiten](https://ucum.org/ucum.html).
+ `type` wird `SUMMARY` sein.
**Das DoubleSummaryDataPoint Objekt**
Das DoubleSummaryDataPoint Objekt enthält den Wert eines einzelnen Datenpunkts in einer Zeitreihe in einer DoubleSummary Metrik.
```
// DoubleSummaryDataPoint is a single data point in a timeseries that describes the
// time-varying values of a Summary metric.
message DoubleSummaryDataPoint {
// The set of labels that uniquely identify this timeseries.
repeated opentelemetry.proto.common.v1.StringKeyValue labels = 1;
// start_time_unix_nano is the last time when the aggregation value was reset
// to "zero". For some metric types this is ignored, see data types for more
// details.
//
// The aggregation value is over the time interval (start_time_unix_nano,
// time_unix_nano].
//
// Value is UNIX Epoch time in nanoseconds since 00:00:00 UTC on 1 January
// 1970.
//
// Value of 0 indicates that the timestamp is unspecified. In that case the
// timestamp may be decided by the backend.
fixed64 start_time_unix_nano = 2;
// time_unix_nano is the moment when this aggregation value was reported.
//
// 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.
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.
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.
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;
}
```
Weitere Informationen finden Sie unter [Übersetzungen im Format OpenTelemetry 0.7.0 in CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation.md).
# Übersetzungen im Format OpenTelemetry 0.7.0 in CloudWatch
CloudWatch führt einige Transformationen durch, um CloudWatch Daten in OpenTelemetry ein Format zu bringen.
**Namespace, Metriknamen und Dimensionen übersetzen**
Diese Attribute sind Schlüssel-Wert-Paare, die im Mapping kodiert sind.
+ Ein Paar enthält den Namespace der Metrik
+ Ein Paar enthält den Namen der Metrik
+ CloudWatch Speichert für jede Dimension das folgende Paar: `metricDatum.Dimensions[i].Name, metricDatum.Dimensions[i].Value`
**Durchschnitt, Summe SampleCount, Min und Max werden übersetzt**
Der Zusammenfassungsdatenpunkt ermöglicht CloudWatch den Export all dieser Statistiken unter Verwendung eines Datenpunkts.
+ `startTimeUnixNano`enthält die CloudWatch `startTime`
+ `timeUnixNano`enthält die CloudWatch `endTime`
+ `sum` enthält die Summen-Statistik.
+ `count`enthält die SampleCount Statistik.
+ `quantile_values` enthält zwei `valueAtQuantile.value`-Objekte:
+ `valueAtQuantile.quantile = 0.0` mit `valueAtQuantile.value = Min value`
+ `valueAtQuantile.quantile = 0.99` mit `valueAtQuantile.value = p99 value`
+ `valueAtQuantile.quantile = 0.999` mit `valueAtQuantile.value = p99.9 value`
+ `valueAtQuantile.quantile = 1.0` mit `valueAtQuantile.value = Max value`
**Ressourcen, die den Metrik-Stream nutzen, können die Durchschnittsstatistik als Sum/ berechnen. SampleCount**
**Einheiten umrechnen**
CloudWatch Einheiten werden der Variante des Unified Codes für Maßeinheiten zugeordnet, bei der Groß- und Kleinschreibung berücksichtigt wird, wie in der folgenden Tabelle dargestellt. Weitere Informationen finden Sie unter [Der einheitliche Code für Maßeinheiten](https://ucum.org/ucum.html).
| CloudWatch | OpenTelemetry |
| --- | --- |
| Sekunde | S |
| Sekunde oder Sekunden | S |
| Mikrosekunde | wir |
| Millisekunden | ms |
| Bytes | Von |
| Kilobytes | kBy |
| Megabyte | MBy |
| Gigabytes | GBy |
| Terabytes | TBy |
| Bits | Bit |
| Kilobits | kbit |
| Megabits | MBit |
| Gigabits | GBit |
| Terabits | Tbit |
| Prozent | % |
| Anzahl | \$1Count\$1 |
| Keine | 1 |
Einheiten, die mit einem Schrägstrich kombiniert werden, werden zugeordnet, indem die OpenTelemetry Konvertierung beider Einheiten angewendet wird. Zum Beispiel Bytes/Second wird By/s zugeordnet.
# 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\$1**
Verwenden Sie `CodedInputStream`. Diese Klasse kann Nachrichten mit größenbegrenztem Abstand lesen.
**C\$1\$1**
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.