Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# CloudWatch sortie de flux métrique au format OpenTelemetry 0.7.0
<a name="CloudWatch-metric-streams-formats-opentelemetry"></a>

OpenTelemetry est une collection d'outils APIs, et SDKs. Vous pouvez l'utiliser pour instrumenter, générer, collecter et exporter des données de télémétrie (métriques, journaux et traces) à des fins d'analyse. OpenTelemetry fait partie de la Cloud Native Computing Foundation. Pour de plus amples informations, veuillez consulter [OpenTelemetry](https://opentelemetry.io/).

Pour plus d'informations sur la spécification OpenTelemetry 0.7.0 complète, voir la [version 0.7.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0).

Un enregistrement Kinesis peut contenir une ou plusieurs structures de `ExportMetricsServiceRequest` OpenTelemetry données. Chaque structure de données commence par un en-tête avec un `UnsignedVarInt32` indiquant la longueur du registre en octets. Chaque `ExportMetricsServiceRequest` peut contenir des données provenant de plusieurs métriques à la fois.

Ce qui suit est une représentation sous forme de chaîne du message de la structure de `ExportMetricsServiceRequest` OpenTelemetry données. OpenTelemetry sérialise le protocole binaire Google Protocol Buffers, ce qui n'est pas lisible par l'homme.

```
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
          }
        }
      }
    }
  }
}
```

**Objet de haut niveau pour sérialiser les données métriques OpenTelemetry **

`ExportMetricsServiceRequest`est le wrapper de haut niveau pour sérialiser la charge utile d'un OpenTelemetry exportateur. Il contient une ou plusieurs `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`est l'objet de niveau supérieur pour représenter les MetricData objets. 

```
// 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;
}
```

**L'objet Ressource**

`Resource` est un objet de paire de valeurs qui contient des informations sur la ressource qui a généré les métriques. Pour les métriques créées par AWS, la structure de données contient l'Amazon Resource Name (ARN) de la ressource liée à la métrique, telle qu'une instance EC2 ou un compartiment S3.

L'objet `Resource` contient un attribut appelé `attributes`, qui stocke une liste des paires de valeurs clés.
+ `cloud.account.id` contient l'ID de compte
+ `cloud.region` contient la région
+ `aws.exporter.arn` contient l'ARN du flux de métriques
+ `cloud.provider` est toujours `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;
}
```

**L' InstrumentationLibraryMetrics objet**

Le champ instrumentation\_library ne sera pas rempli. Nous ne remplirons que le champ de métriques que nous exportons.

```
// 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;
}
```

**L'objet Metric**

L'objet de métrique contient un champ de données `DoubleSummary` qui contient une liste de `DoubleSummaryDataPoint`.

```
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;
}
```

**L' MetricDescriptor objet**

L' MetricDescriptor objet contient des métadonnées. Pour plus d'informations, consultez [metrics.proto](https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/metrics/v1/metrics.proto#L110) sur. GitHub

Pour les flux métriques, le contenu MetricDescriptor est le suivant :
+ `name` sera `amazonaws.com/{{metric_namespace}}/{{metric_name}}`
+ `description` sera vide.
+ `unit` sera rempli en mappant l'unité de référence de la métrique à la variante sensible à la casse du code unifié pour les unités de mesure. Pour de plus amples informations, veuillez consulter [Traductions au format OpenTelemetry 0.7.0 en CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation.md) and le [Code unifié des unités de mesure](https://ucum.org/ucum.html).
+ `type` sera `SUMMARY`.

**L' DoubleSummaryDataPoint objet**

L' DoubleSummaryDataPoint objet contient la valeur d'un point de données unique dans une série chronologique dans une DoubleSummary métrique.

```
// 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;
}
```

Pour de plus amples informations, veuillez consulter [Traductions au format OpenTelemetry 0.7.0 en CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation.md).