# Usar fluxos de métricas
Você pode usar *fluxos de métricas* para transmitir continuamente as métricas do CloudWatch para um destino de sua preferência, com entrega quase em tempo real e baixa latência. Entre os destinos compatíveis estão os destinos da AWS, como o Amazon Simple Storage Service e vários destinos de provedores de serviços de terceiros.
Há três cenários principais de uso para os fluxos de métricas do CloudWatch:
+ **Configuração personalizada com o Firehose**: crie um fluxo de métricas e direcione-o para um fluxo de entrega do Amazon Data Firehose que envie suas métricas do CloudWatch para onde você deseja. Você pode transmiti-las para um data lake, como o Amazon S3, ou para qualquer destino ou endpoint compatível com o Firehose, incluindo provedores externos. Os formatos JSON, OpenTelemetry 1.0.0 e OpenTelemetry 0.7.0 são compatíveis nativamente ou você pode configurar transformações no fluxo de entrega do Firehose para converter os dados em um formato diferente, como o Parquet. Com um fluxo de métricas, você pode atualizar continuamente os dados de monitoramento ou combinar esses dados de métricas do CloudWatch com dados de faturamento e performance para criar conjuntos de dados avançados. Em seguida, você pode usar ferramentas como o Amazon Athena para obter insights sobre otimização de custos, performance de recursos e utilização de recursos.
+ **Configuração rápida do S3**: crie o fluxo para o Amazon Simple Storage Service com um processo de configuração rápida. Por padrão, o CloudWatch cria os recursos necessários para o fluxo. Os formatos JSON, OpenTelemetry 1.0.0 e OpenTelemetry 0.7.0 são compatíveis.
+ **Configuração rápida do parceiro da AWS**: o CloudWatch oferece uma experiência de configuração rápida para alguns parceiros externos. Você pode usar provedores de serviços terceirizados para monitorar, solucionar problemas e analisar suas aplicações usando os dados transmitidos do CloudWatch. Quando você usa o fluxo de trabalho de configuração rápida de parceiros, é necessário fornecer apenas um URL de destino e uma chave de API para o destino, e o CloudWatch cuida do restante da configuração. A configuração rápida de parceiros está disponível para os seguintes provedores externos:
+ Datadog
+ Dynatrace
+ Elastic
+ New Relic
+ Splunk Observability Cloud
+ SumoLogic
É possível transmitir todas as suas métricas do CloudWatch ou usar filtros para transmitir somente métricas especificadas. Cada fluxo de métrica pode conter até 1000 filtros que incluem ou excluem namespaces de métrica ou métricas específicas. Um único fluxo de métricas pode ter somente filtros de inclusão ou exclusão, mas não ambos.
Depois que um fluxo de métrica é criado, se novas métricas forem criadas que correspondam aos filtros no local, as novas métricas serão incluídas no fluxo automaticamente.
Não há limite para o número de fluxos de métrica por conta ou por região e não há limite para o número de atualizações de métricas que estão sendo transmitidas.
Cada fluxo pode usar os formatos JSON, OpenTelemetry 1.0.0 ou OpenTelemetry 0.7.0. Você pode editar o formato de saída de um fluxo de métrica a qualquer momento, por exemplo, para atualizar do OpenTelemetry 0.7.0 para o OpenTelemetry 1.0.0. Para obter mais informações sobre os formatos de saída, consulte [Saída do fluxo de métricas do CloudWatch no formato JSON](CloudWatch-metric-streams-formats-json.md), [Saída do fluxo de métricas do CloudWatch no formato OpenTelemetry 1.0.0](CloudWatch-metric-streams-formats-opentelemetry-100.md) e [Saída do fluxo de métricas do CloudWatch no formato OpenTelemetry 0.7.0](CloudWatch-metric-streams-formats-opentelemetry.md).
Para fluxos de métricas em contas de monitoramento, escolha se você deseja incluir métricas das contas de origem vinculadas a essa conta de monitoramento. Para obter mais informações, consulte [Observabilidade entre contas do CloudWatch](CloudWatch-Unified-Cross-Account.md).
Os fluxos de métrica sempre incluem as estatísticas `Minimum`, `Maximum`, `SampleCount` e `Sum`. Você também pode optar por incluir estatísticas adicionais mediante um custo adicional. Para obter mais informações, consulte [Estatísticas que podem ser transmitidas](CloudWatch-metric-streams-statistics.md).
O preço dos fluxos de métrica é baseado no número de atualizações de métricas. Você também vai gerar cobranças do Firehose para o fluxo de entrega usado no fluxo de métrica. Para obter mais informações, consulte [Preços do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**Topics**
+ [Configurar um fluxo de métricas](CloudWatch-metric-streams-setup.md)
+ [Estatísticas que podem ser transmitidas](CloudWatch-metric-streams-statistics.md)
+ [Operação e manutenção do fluxo de métricas](CloudWatch-metric-streams-operation.md)
+ [Monitorar seus fluxos de métrica com métricas do CloudWatch](CloudWatch-metric-streams-monitoring.md)
+ [Confiança entre o CloudWatch e o Firehose](CloudWatch-metric-streams-trustpolicy.md)
+ [Saída do fluxo de métricas do CloudWatch no formato JSON](CloudWatch-metric-streams-formats-json.md)
+ [Saída do fluxo de métricas do CloudWatch no formato OpenTelemetry 1.0.0](CloudWatch-metric-streams-formats-opentelemetry-100.md)
+ [Saída do fluxo de métricas do CloudWatch no formato OpenTelemetry 0.7.0](CloudWatch-metric-streams-formats-opentelemetry.md)
+ [Solução de problemas relacionados aos fluxos de métricas no CloudWatch](CloudWatch-metric-streams-troubleshoot.md)
# Configurar um fluxo de métricas
Use as etapas nas seções a seguir para configurar um fluxo de métricas do CloudWatch.
Depois que um fluxo de métricas é criado, o tempo necessário para que os dados de métrica sejam exibidos no destino depende das configurações de buffer no fluxo de entrega do Firehose. O buffer é expresso em tamanho máximo da carga útil ou tempo máximo de espera, o que for atingido primeiro. Se estes forem definidos com os valores mínimos (60 segundos, 1 MB), a latência esperada será dentro de 3 minutos, se os namespaces do CloudWatch selecionados tiverem atualizações de métricas ativas.
Em um fluxo de métricas do CloudWatch, os dados são enviados a cada minuto. Os dados podem chegar ao destino final fora de ordem. Todas as métricas nos namespaces especificados são enviadas no fluxo de métricas, com a exceção de métricas com um carimbo de data/hora com mais de dois dias de idade.
Para cada combinação de nome da métrica e namespace que você transmitir, todas as combinações de dimensão desse nome da métrica e namespace são transmitidas.
Para fluxos de métricas em contas de monitoramento, escolha se você deseja incluir métricas das contas de origem vinculadas a essa conta de monitoramento. Para obter mais informações, consulte [Observabilidade entre contas do CloudWatch](CloudWatch-Unified-Cross-Account.md).
Para criar e gerenciar um fluxo de métricas, você deve estar conectado a uma conta que tenha a política **CloudWatchFullAccess** e a permissão `iam:PassRole` ou uma conta que tenha a seguinte lista de permissões:
+ `iam:PassRole`
+ `cloudwatch:PutMetricStream`
+ `cloudwatch:DeleteMetricStream`
+ `cloudwatch:GetMetricStream`
+ `cloudwatch:ListMetricStreams`
+ `cloudwatch:StartMetricStreams`
+ `cloudwatch:StopMetricStreams`
Para que o CloudWatch configure a função do IAM necessária para fluxos de métricas, você também deve ter as permissões `iam:CreateRole` e `iam:PutRolePolicy`.
**Importante**
Um usuário com `cloudwatch:PutMetricStream` tem acesso aos dados de métrica do CloudWatch que estão sendo transmitidos, mesmo que não tenha a permissão `cloudwatch:GetMetricData`.
**Topics**
+ [Configuração personalizada com o Firehose](CloudWatch-metric-streams-setup-datalake.md)
+ [Use a configuração rápida do Amazon S3](CloudWatch-metric-streams-setup-Quick-S3.md)
+ [Configuração rápida de parceiros](CloudWatch-metric-streams-QuickPartner.md)
# Configuração personalizada com o Firehose
Use esse método para criar um fluxo de métricas e direcioná-lo a um fluxo de entrega do Amazon Data Firehose que envia suas métricas do CloudWatch para onde você deseja. Você pode transmiti-las para um data lake, como o Amazon S3, ou para qualquer destino ou endpoint compatível com o Firehose, incluindo provedores externos.
Os formatos JSON, OpenTelemetry 1.0.0 e OpenTelemetry 0.7.0 são compatíveis nativamente ou você pode configurar transformações no fluxo de entrega do Firehose para converter os dados em um formato diferente, como o Parquet. Com um fluxo de métricas, você pode atualizar continuamente os dados de monitoramento ou combinar esses dados de métricas do CloudWatch com dados de faturamento e performance para criar conjuntos de dados avançados. Em seguida, você pode usar ferramentas como o Amazon Athena para obter insights sobre otimização de custos, performance de recursos e utilização de recursos.
Você pode usar o console do CloudWatch, a AWS CLI, o AWS CloudFormation ou o AWS Cloud Development Kit (AWS CDK) para configurar um fluxo de métricas.
O fluxo de entrega do Firehose usado para o fluxo de métricas deve estar na mesma conta e na mesma região em que o fluxo de métricas está configurado. Para obter a funcionalidade entre regiões, é possível configurar o fluxo de entrega do Firehose para transmitir a um destino final que esteja em outra conta ou região.
## Console do CloudWatch
Esta seção descreve como usar o console do CloudWatch para configurar um fluxo de métricas usando o Firehose.
**Para configurar um fluxo de métricas personalizado usando o Firehose**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Metrics** (Métricas), **Streams** (Fluxos). Em seguida, escolha **Create metric stream** (Criar fluxo de métrica).
1. (Opcional) Se estiver conectado a uma conta configurada como uma conta de monitoramento na observabilidade entre contas do CloudWatch, você poderá escolher se deseja incluir métricas de contas de origem vinculadas nesse fluxo de métricas. Para incluir métricas de contas de origem, escolha **Include source account metrics** (Incluir métricas da conta de origem).
1. Escolha **Configuração personalizada com Firehose**.
1. Em **Selecionar o fluxo do Kinesis Data Firehose**, selecione o fluxo de entrega do Firehose a ser usado. Ele deve estar na mesma conta. O formato padrão para essa opção é OpenTelemetry 0.7.0, mas é possível alterar o formato posteriormente nesse procedimento.
Em seguida, selecione o fluxo de entrega do Firehose a ser usado em **Selecionar o fluxo de entrega do Firehose**.
1. (Opcional) Você pode escolher **Selecionar perfil de serviço existente** para usar um perfil do IAM existente em vez de fazer com que o CloudWatch crie um novo para você.
1. (Opcional) Para alterar o formato de saída do formato padrão para seu cenário, escolha **Change output format** (Alterar o formato de saída). Os formatos compatíveis são JSON, OpenTelemetry 1.0.0 e OpenTelemetry 0.7.0.
1. Em **Métricas a serem transmitidas**, escolha **Todas as métricas** ou **Selecionar métricas**.
Se você escolher **Todas as métricas**, todas as métricas dessa conta serão incluídas no fluxo.
Avalie bem se deseja transmitir todas as métricas, pois quanto mais métricas forem transmitidas, maiores serão as cobranças do fluxo de métrica.
Se você escolgher **Selecionar métrica**, faça o seguinte:
+ Para transmitir a maioria dos namespaces métricos, escolha **Excluir** e selecione os namespaces ou métricas a serem excluídos. Ao especificar um namespace em **Excluir**, você também pode selecionar algumas métricas específicas desse namespace para excluir. Se você optar por excluir um namespace, mas não selecionar métricas nesse namespace, todas as métricas desse namespace serão excluídas.
+ Para incluir apenas alguns namespaces de métrica ou métricas no fluxo de métricas, escolha **Incluir** e selecione os namespaces ou métricas que deseja incluir. Se você optar por incluir um namespace, mas não selecionar métricas nesse namespace, todas as métricas desse namespace serão incluídas.
1. (Opcional) Para transmitir estatísticas adicionais para algumas dessas métricas além de Mínimo, Máximo, SampleCount e Soma, selecione **Adicionar estatísticas adicionais**. Escolha **Add recommended metrics** (Adicionar métricas recomendadas) para adicionar algumas estatísticas comumente usadas ou selecione manualmente o namespace e o nome da métrica para os quais deseja transmitir estatísticas adicionais. Em seguida, selecione as estatísticas adicionais que deseja transmitir.
Em seguida, para escolher outro grupo de métricas para o qual transmitir um conjunto diferente de estatísticas adicionais, escolha **Add additional statistics** (Adicionar outras estatísticas). Cada métrica pode incluir até 20 estatísticas adicionais, e um fluxo de métrica pode ter até 100 métricas com estatísticas adicionais.
A transmissão de estatísticas adicionais gera mais cobranças. Para obter mais informações, consulte [Estatísticas que podem ser transmitidas](CloudWatch-metric-streams-statistics.md).
Para ver as definições das estatísticas adicionais, consulte [Definições de estatísticas do CloudWatch](Statistics-definitions.md).
1. (Opcional) Personalize o nome do novo fluxo de métricas em **Metric stream name** (Nome do fluxo de métricas).
1. Escolha **Create metric stream** (Criar filtro de métrica).
## AWS CLI ou API da AWS
Use as etapas a seguir para criar um fluxo de métricas do CloudWatch.
**Para usar a AWS CLI ou a API da AWS para criar um fluxo de métricas**
1. Se estiver transmitindo para o Amazon S3, primeiro crie o bucket. Para mais informações, consulte [ Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html).
1. Crie o fluxo de entrega do Firehose. Para obter mais informações, consulte [Criar um fluxo do Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html).
1. Crie um perfil do IAM que permita que o CloudWatch grave no fluxo de entrega do Firehose. Para obter mais informações sobre o conteúdo dessa função, consulte [Confiança entre o CloudWatch e o Firehose](CloudWatch-metric-streams-trustpolicy.md).
1. Use o comando `aws cloudwatch put-metric-stream` da CLI a API `PutMetricStream` para criar o fluxo de métricas do CloudWatch.
## AWS CloudFormation
É possível usar o CloudFormation para configurar um fluxo de métricas. Para obter mais informações, consulte [AWS::CloudWatch::MetricStream](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudwatch-metricstream.html).
**Para usar o CloudFormation para criar um fluxo de métricas**
1. Se estiver transmitindo para o Amazon S3, primeiro crie o bucket. Para mais informações, consulte [ Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html).
1. Crie o fluxo de entrega do Firehose. Para obter mais informações, consulte [Criar um fluxo do Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html).
1. Crie um perfil do IAM que permita que o CloudWatch grave no fluxo de entrega do Firehose. Para obter mais informações sobre o conteúdo dessa função, consulte [Confiança entre o CloudWatch e o Firehose](CloudWatch-metric-streams-trustpolicy.md).
1. Crie o fluxo no CloudFormation. Para obter mais informações, consulte [AWS::CloudWatch::MetricStream](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudwatch-metricstream.html).
## AWS Cloud Development Kit (AWS CDK)
É possível usar o AWS Cloud Development Kit (AWS CDK) para configurar um fluxo de métricas.
**Para usar o AWS CDK para criar um fluxo de métricas**
1. Se estiver transmitindo para o Amazon S3, primeiro crie o bucket. Para mais informações, consulte [ Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html).
1. Crie o fluxo de entrega do Firehose. Para obter mais informações, consulte [Creating an Amazon Data Firehose Delivery Stream](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html).
1. Crie um perfil do IAM que permita que o CloudWatch grave no fluxo de entrega do Firehose. Para obter mais informações sobre o conteúdo dessa função, consulte [Confiança entre o CloudWatch e o Firehose](CloudWatch-metric-streams-trustpolicy.md).
1. Crie o fluxo de métricas. O recurso de fluxo de métricas está disponível no AWS CDK como construção de nível 1 (L1) chamado `CfnMetricStream`. Para obter mais informações, consulte [Usar construções L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using.html).
# Use a configuração rápida do Amazon S3
O método **Configuração rápida do S3** funcionará bem se você quiser configurar rapidamente um fluxo para o Amazon S3 e não precisar de qualquer transformação de formatação além dos formatos compatíveis JSON, OpenTelemetry 1.0.0 e OpenTelemetry 0.7.0. O CloudWatch criará todos os recursos necessários, incluindo o fluxo de entrega do Firehose e os perfis do IAM necessários. O formato padrão para essa opção é JSON, mas você pode alterar o formato ao configurar o fluxo.
Como alternativa, se você quiser que o formato final seja o formato Parquet ou Optimized Row Columnar (ORC), você deverá seguir as etapas em [Configuração personalizada com o Firehose](CloudWatch-metric-streams-setup-datalake.md).
## Console do CloudWatch
Esta seção descreve como usar o console do CloudWatch para configurar um fluxo de métricas do Amazon S3 usando a configuração rápida do S3.
**Configurar um fluxo de métricas usando a configuração rápida do S3**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Metrics** (Métricas), **Streams** (Fluxos). Em seguida, escolha **Create metric stream** (Criar fluxo de métrica).
1. (Opcional) Se estiver conectado a uma conta configurada como uma conta de monitoramento na observabilidade entre contas do CloudWatch, você poderá escolher se deseja incluir métricas de contas de origem vinculadas nesse fluxo de métricas. Para incluir métricas de contas de origem, escolha **Include source account metrics** (Incluir métricas da conta de origem).
1. Selecione **Configuração rápida do S3**. O CloudWatch criará todos os recursos necessários, incluindo o fluxo de entrega do Firehose e os perfis do IAM necessários. O formato padrão para essa opção é JSON, mas é possível alterar o formato posteriormente neste procedimento.
1. (Opcional) Escolha **Selecionar recursos existentes** para usar um bucket do S3 existente ou perfis do IAM existentes em vez de fazer com que o CloudWatch crie novos recursos para você.
1. (Opcional) Para alterar o formato de saída do formato padrão para seu cenário, escolha **Change output format** (Alterar o formato de saída). Os formatos compatíveis são JSON, OpenTelemetry 1.0.0 e OpenTelemetry 0.7.0.
1. Em **Métricas a serem transmitidas**, escolha **Todas as métricas** ou **Selecionar métricas**.
Se você escolher **Todas as métricas**, todas as métricas dessa conta serão incluídas no fluxo.
Avalie bem se deseja transmitir todas as métricas, pois quanto mais métricas forem transmitidas, maiores serão as cobranças do fluxo de métrica.
Se você escolgher **Selecionar métrica**, faça o seguinte:
+ Para transmitir a maioria dos namespaces métricos, escolha **Excluir** e selecione os namespaces ou métricas a serem excluídos. Ao especificar um namespace em **Excluir**, você também pode selecionar algumas métricas específicas desse namespace para excluir. Se você optar por excluir um namespace, mas não selecionar métricas nesse namespace, todas as métricas desse namespace serão excluídas.
+ Para incluir apenas alguns namespaces de métrica ou métricas no fluxo de métricas, escolha **Incluir** e selecione os namespaces ou métricas que deseja incluir. Se você optar por incluir um namespace, mas não selecionar métricas nesse namespace, todas as métricas desse namespace serão incluídas.
1. (Opcional) Para transmitir estatísticas adicionais para algumas dessas métricas além de Mínimo, Máximo, SampleCount e Soma, selecione **Adicionar estatísticas adicionais**. Escolha **Add recommended metrics** (Adicionar métricas recomendadas) para adicionar algumas estatísticas comumente usadas ou selecione manualmente o namespace e o nome da métrica para os quais deseja transmitir estatísticas adicionais. Em seguida, selecione as estatísticas adicionais que deseja transmitir.
Em seguida, para escolher outro grupo de métricas para o qual transmitir um conjunto diferente de estatísticas adicionais, escolha **Add additional statistics** (Adicionar outras estatísticas). Cada métrica pode incluir até 20 estatísticas adicionais, e um fluxo de métrica pode ter até 100 métricas com estatísticas adicionais.
A transmissão de estatísticas adicionais gera mais cobranças. Para obter mais informações, consulte [Estatísticas que podem ser transmitidas](CloudWatch-metric-streams-statistics.md).
Para ver as definições das estatísticas adicionais, consulte [Definições de estatísticas do CloudWatch](Statistics-definitions.md).
1. (Opcional) Personalize o nome do novo fluxo de métricas em **Metric stream name** (Nome do fluxo de métricas).
1. Escolha **Create metric stream** (Criar filtro de métrica).
# Configuração rápida de parceiros
O CloudWatch oferece uma experiência de configuração rápida para os parceiros externos a seguir. Para usar esse fluxo de trabalho, você precisa fornecer apenas um URL de destino e uma chave de API para seu destino. O CloudWatch cuida do restante da configuração, incluindo a criação do fluxo de entrega do Firehose e os perfis do IAM necessários.
**Importante**
Antes de usar a configuração rápida do parceiro para criar um fluxo de métricas, é altamente recomendável que você leia a documentação desse parceiro, que está relacionada na lista a seguir.
+ [Datadog](https://docs.datadoghq.com/integrations/guide/aws-cloudwatch-metric-streams-with-kinesis-data-firehose/)
+ [Dynatrace](https://www.dynatrace.com/support/help/dynatrace-api/basics/dynatrace-api-authentication)
+ [Elastic](https://www.elastic.co/docs/current/integrations/awsfirehose)
+ [New Relic](https://docs.newrelic.com/install/aws-cloudwatch/)
+ [Splunk Observability Cloud](https://docs.splunk.com/observability/en/gdi/get-data-in/connect/aws/aws-console-ms.html)
+ [SumoLogic](https://www.sumologic.com)
Quando você configura um fluxo de métricas para um desses parceiros, o fluxo é criado com algumas configurações padrão, conforme listado nas seções a seguir.
**Topics**
+ [Configurar um fluxo de métricas usando a configuração rápida de parceiros](#CloudWatch-metric-streams-QuickPartner-setup)
+ [Padrões de fluxo do Datadog](#CloudWatch-metric-streams-QuickPartner-Datadog)
+ [Padrões de fluxo do Dynatrace](#CloudWatch-metric-streams-QuickPartner-Dynatrace)
+ [Padrões de fluxo do Elastic](#CloudWatch-metric-streams-QuickPartner-Elastic)
+ [Padrões de fluxo da New Relic](#CloudWatch-metric-streams-QuickPartner-NewRelic)
+ [Padrões de fluxo do Splunk Observability Cloud](#CloudWatch-metric-streams-QuickPartner-Splunk)
+ [Padrões de fluxo do Sumo Logic](#CloudWatch-metric-streams-QuickPartner-Sumologic)
## Configurar um fluxo de métricas usando a configuração rápida de parceiros
O CloudWatch oferece uma opção de configuração rápida para alguns parceiros terceirizados. Antes de iniciar as etapas desta seção, é necessário ter determinadas informações sobre o parceiro. Essas informações podem incluir um URL de destino e/ou uma chave de API para o destino de seu parceiro. Você também deve ler a documentação no site do parceiro vinculado na seção anterior e os padrões para esse parceiro listados nas seções a seguir.
Para transmitir a um destino de terceiros que não seja compatível com a configuração rápida, você pode seguir as instruções em Siga as instruções em [Configuração personalizada com o Firehose](CloudWatch-metric-streams-setup-datalake.md) para configurar um fluxo usando o Firehose. Em seguida, envie essas métricas do Firehose ao destino final.
**Usar a configuração rápida de parceiros para criar um fluxo de métricas para um provedor externo**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Metrics** (Métricas), **Streams** (Fluxos). Em seguida, escolha **Create metric stream** (Criar fluxo de métrica).
1. (Opcional) Se estiver conectado a uma conta configurada como uma conta de monitoramento na observabilidade entre contas do CloudWatch, você poderá escolher se deseja incluir métricas de contas de origem vinculadas nesse fluxo de métricas. Para incluir métricas de contas de origem, escolha **Include source account metrics** (Incluir métricas da conta de origem).
1. Escolha **Configuração rápida do parceiro da Amazon Web Services**
1. Selecione o nome do parceiro para o qual você deseja transmitir as métricas.
1. Para um **URL do endpoint**, insira o URL de destino.
1. Para **Chave de acesso** ou **Chave de API**, insira a chave de acesso para o parceiro. Nem todos os parceiros precisam de uma chave de acesso.
1. Em **Métricas a serem transmitidas**, escolha **Todas as métricas** ou **Selecionar métricas**.
Se você escolher **Todas as métricas**, todas as métricas dessa conta serão incluídas no fluxo.
Avalie bem se deseja transmitir todas as métricas, pois quanto mais métricas forem transmitidas, maiores serão as cobranças do fluxo de métrica.
Se você escolgher **Selecionar métrica**, faça o seguinte:
+ Para transmitir a maioria dos namespaces métricos, escolha **Excluir** e selecione os namespaces ou métricas a serem excluídos. Ao especificar um namespace em **Excluir**, você também pode selecionar algumas métricas específicas desse namespace para excluir. Se você optar por excluir um namespace, mas não selecionar métricas nesse namespace, todas as métricas desse namespace serão excluídas.
+ Para incluir apenas alguns namespaces de métrica ou métricas no fluxo de métricas, escolha **Incluir** e selecione os namespaces ou métricas que deseja incluir. Se você optar por incluir um namespace, mas não selecionar métricas nesse namespace, todas as métricas desse namespace serão incluídas.
1. (Opcional) Para transmitir estatísticas adicionais para algumas dessas métricas além de Mínimo, Máximo, SampleCount e Soma, selecione **Adicionar estatísticas adicionais**. Escolha **Add recommended metrics** (Adicionar métricas recomendadas) para adicionar algumas estatísticas comumente usadas ou selecione manualmente o namespace e o nome da métrica para os quais deseja transmitir estatísticas adicionais. Em seguida, selecione as estatísticas adicionais que deseja transmitir.
Em seguida, para escolher outro grupo de métricas para o qual transmitir um conjunto diferente de estatísticas adicionais, escolha **Add additional statistics** (Adicionar outras estatísticas). Cada métrica pode incluir até 20 estatísticas adicionais, e um fluxo de métrica pode ter até 100 métricas com estatísticas adicionais.
A transmissão de estatísticas adicionais gera mais cobranças. Para obter mais informações, consulte [Estatísticas que podem ser transmitidas](CloudWatch-metric-streams-statistics.md).
Para ver as definições das estatísticas adicionais, consulte [Definições de estatísticas do CloudWatch](Statistics-definitions.md).
1. (Opcional) Personalize o nome do novo fluxo de métricas em **Metric stream name** (Nome do fluxo de métricas).
1. Escolha **Create metric stream** (Criar filtro de métrica).
## Padrões de fluxo do Datadog
Os fluxos de configuração rápida de parceiros para o Datadog usam os seguintes padrões:
+ **Formato de saída:** OpenTelemetry 0.7.0
+ **Codificação de conteúdo de fluxo do Firehose** GZIP
+ **Opções de buffer de fluxo do Firehose** Intervalo de 60 segundos, tamanho de 4 MBs
+ **Opção de nova tentativa de fluxo do Firehose** Duração de 60 segundos
Quando você usa a configuração rápida de parceiros para criar um fluxo de métricas para o Datadog e transmite determinadas métricas, por padrão essas métricas incluem algumas estatísticas adicionais. O streaming de estatísticas adicionais pode incorrer em cobranças adicionais. Para obter mais informações sobre estatísticas e suas cobranças, consulte [Estatísticas que podem ser transmitidas](CloudWatch-metric-streams-statistics.md).
A lista a seguir mostra as métricas que têm estatísticas adicionais transmitidas por padrão, se você optar por transmitir essas métricas. Você pode optar por desmarcar essas estatísticas adicionais antes de iniciar a transmissão.
+ **`Duration` no `AWS/Lambda`:** p50, p80, p95, p99, p99.9
+ **`PostRuntimeExtensionDuration` no `AWS/Lambda`:** p50, p99
+ **`FirstByteLatency` e `TotalRequestLatency` no `AWS/S3`:** p50, p90, p95, p99, p99.9
+ **`ResponseLatency` no `AWS/Polly` e `TargetResponseTime` no AWS/ApplicationELB:** p50, p90, p95, p99
+ **`Latency` e `IntegrationLatency` na `AWS/ApiGateway`:** p90, p95, p99
+ **`Latency` e `TargetResponseTime` no `AWS/ELB`:** p95, p99
+ **`RequestLatency` no `AWS/AppRunner`:** p50, p95, p99
+ **`ActivityTime`, `ExecutionTime`, `LambdaFunctionRunTime`, `LambdaFunctionScheduleTime`, `LambdaFunctionTime`, `ActivityRunTime`, e `ActivityScheduleTime` nos `AWS/States`:** p95, p99
+ **`EncoderBitRate`, `ConfiguredBitRate`, e `ConfiguredBitRateAvailable` no `AWS/MediaLive`:** p90
+ **`Latency` no `AWS/AppSync`:** p90
## Padrões de fluxo do Dynatrace
Os fluxos de configuração rápida de parceiros para o Dynatrace usam os seguintes padrões:
+ **Formato de saída:** OpenTelemetry 0.7.0
+ **Codificação de conteúdo de fluxo do Firehose** GZIP
+ **Opções de buffer de fluxo do Firehose** Intervalo de 60 segundos, tamanho de 5 MBs
+ **Opção de nova tentativa de fluxo do Firehose** Duração de 600 segundos
## Padrões de fluxo do Elastic
Os fluxos de configuração rápida de parceiros para o Elastic usam os seguintes padrões:
+ **Formato de saída:** OpenTelemetry 1.0.0
+ **Codificação de conteúdo de fluxo do Firehose** GZIP
+ **Opções de buffer de fluxo do Firehose** Intervalo de 60 segundos, tamanho de 1 MB
+ **Opção de nova tentativa de fluxo do Firehose** Duração de 60 segundos
## Padrões de fluxo da New Relic
Os fluxos de configuração rápida de parceiros para a New Relic usam os seguintes padrões:
+ **Formato de saída:** OpenTelemetry 0.7.0
+ **Codificação de conteúdo de fluxo do Firehose** GZIP
+ **Opções de buffer de fluxo do Firehose** Intervalo de 60 segundos, tamanho de 1 MB
+ **Opção de nova tentativa de fluxo do Firehose** Duração de 60 segundos
## Padrões de fluxo do Splunk Observability Cloud
Os fluxos de configuração rápida de parceiros para o Splunk Observability Cloud usam os seguintes padrões:
+ **Formato de saída:** OpenTelemetry 1.0.0
+ **Codificação de conteúdo de fluxo do Firehose** GZIP
+ **Opções de buffer de fluxo do Firehose** Intervalo de 60 segundos, tamanho de 1 MB
+ **Opção de nova tentativa de fluxo do Firehose** Duração de 300 segundos
## Padrões de fluxo do Sumo Logic
Os fluxos de configuração rápida de parceiros para a Sumo Logic usam os seguintes padrões:
+ **Formato de saída:** OpenTelemetry 0.7.0
+ **Codificação de conteúdo de fluxo do Firehose** GZIP
+ **Opções de buffer de fluxo do Firehose** Intervalo de 60 segundos, tamanho de 1 MB
+ **Opção de nova tentativa de fluxo do Firehose** Duração de 60 segundos
# Estatísticas que podem ser transmitidas
Os fluxos de métrica sempre incluem as seguintes estatísticas: `Minimum`, `Maximum`, `SampleCount` e `Sum`. Você também pode optar por incluir as seguintes estatísticas adicionais em um fluxo de métrica. Essa escolha é feita por métrica. Para mais informações sobre estas estatísticas, consulte [Definições de estatísticas do CloudWatch](Statistics-definitions.md).
+ Valores de percentil como p95 ou p99 (para fluxos com formato JSON ou OpenTelemetry)
+ Média aparada (somente para fluxos com o formato JSON)
+ Média winsorizada (somente para fluxos com o formato JSON)
+ Contagem aparada (somente para fluxos com o formato JSON)
+ Soma aparada (somente para fluxos com o formato JSON)
+ Classificação de percentil (somente para fluxos com o formato JSON)
+ Média interquartil (somente para fluxos com o formato JSON)
A transmissão de estatísticas adicionais gera cobranças adicionais. A transmissão de uma a cinco dessas estatísticas adicionais para uma determinada métrica é cobrada como uma atualização de métrica adicional. Depois disso, cada conjunto adicional de até cinco dessas estatísticas é cobrado como outra atualização métrica.
Por exemplo, suponha que você esteja transmitindo as seis estatísticas adicionais a seguir para uma métrica: p95, p99, p99,9, média aparada, média winsorizada e soma aparada. Cada atualização dessa métrica é cobrada como três atualizações de métrica: uma para a atualização de métrica que inclui as estatísticas padrão, uma para as primeiras cinco estatísticas adicionais e uma para a sexta estatística adicional. A adição de outras quatro estatísticas, totalizando dez, não aumentaria a cobrança, mas uma décima primeira estatística adicional aumentaria.
Quando você especifica uma combinação de nome da métrica e namespace para transmitir estatísticas adicionais, todas as combinações de dimensão desse nome da métrica e namespace são transmitidas com as estatísticas adicionais.
Os fluxos de métricas do CloudWatch publicam uma nova métrica, `TotalMetricUpdate`, que reflete o número básico de atualizações métricas mais atualizações adicionais de métricas incorridas pela transmissão de estatísticas adicionais. Para obter mais informações, consulte [Monitorar seus fluxos de métrica com métricas do CloudWatch](CloudWatch-metric-streams-monitoring.md).
Para obter mais informações, consulte [Preços do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**nota**
Algumas métricas não são compatíveis com percentis. As estatísticas de percentil para essas métricas são excluídas do fluxo e não geram cobranças de fluxo de métrica. Um exemplo dessas estatísticas que não são compatíveis com percentis são algumas métricas no namespace `AWS/ECS`.
As estatísticas adicionais que você configurar só são transmitidas se corresponderem aos filtros do fluxo. Por exemplo, se você criar um fluxo que tenha apenas `EC2` e `RDS` nos filtros de inclusão e, em seguida, sua configuração de estatísticas listar `EC2` e `Lambda`, o fluxo inclui métricas do `EC2` com estatísticas adicionais, métricas do `RDS` apenas com as estatísticas padrão e não inclui nenhuma estatística do `Lambda`.
# Operação e manutenção do fluxo de métricas
Os fluxos de métricas estão sempre em um destes dois estados: **Running** (Em execeução) ou **Stopped** (Interrompido).
+ **Running**: o fluxo de métricas está funcionando corretamente. Pode não haver dados de métrica transmitidos ao destino por causa dos filtros no fluxo.
+ **Stopped**: o fluxo de métrica foi explicitamente interrompido por alguém, e não por causa de um erro. Pode ser útil interromper o fluxo para pausar temporariamente o fluxo de dados sem excluir o fluxo.
Se você interromper e reiniciar um fluxo de métricas, os dados de métrica que foram publicados no CloudWatch enquanto o fluxo de métricas foi interrompido não serão preenchidos para o fluxo de métricas.
Se você alterar o formato de saída de um fluxo de métricas, em certos casos, poderá ver uma pequena quantidade de dados métricos gravados no destino no formato antigo e no novo formato. Para evitar essa situação, é possível criar um fluxo de entrega do Firehose com a mesma configuração que o atual, depois mudar para o novo fluxo de entrega do Firehose e alterar o formato de saída ao mesmo tempo. Dessa forma, os registros do Kinesis com formato de saída diferente são armazenados no Amazon S3, em objetos separados. Posteriormente, você poderá direcionar o tráfego de volta ao fluxo de entrega original do Firehose e excluir o segundo fluxo de entrega.
**Para visualizar, editar, interromper e iniciar seus fluxos de métricas**
1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Metrics** (Métricas), **Streams** (Fluxos).
A lista de fluxos é exibida, e a coluna **Status** exibe se cada fluxo está sendo executado ou interrompido.
1. Para interromper ou iniciar um fluxo de métrica, selecione o fluxo e escolha **Stop** (Interromper) ou **Start** (Iniciar).
1. Para ver os detalhes sobre um fluxo de métrica, selecione o fluxo e escolha **View details** (Visualizar detalhes).
1. Para alterar o formato de saída do fluxo, os filtros, o fluxo de destino do Firehose ou os perfis, escolha **Editar** e faça as alterações desejadas.
Se você alterar os filtros, poderá haver algumas lacunas nos dados de métrica durante a transição.
# Monitorar seus fluxos de métrica com métricas do CloudWatch
Os fluxos de métrica emitem métricas do CloudWatch sobre sua integridade e operação no namespace `AWS/CloudWatch/MetricStreams`. São emitidas as métricas a seguir. Essas métricas são emitidas com uma dimensão `MetricStreamName` e sem dimensão. É possível usar as métricas sem dimensões para ver métricas agregadas de todos os fluxos de métricas. Você pode usar as métricas com a dimensão `MetricStreamName` para ver as métricas sobre apenas esse fluxo de métricas.
Para todas essas métricas, os valores são emitidos apenas para fluxos de métricas que estão no estado **Running** (Em execução).
| Métrica | Descrição |
| --- | --- |
| `MetricUpdate` | As atualizações de métricas numéricas enviadas à transmissão de métricas. Se nenhuma atualização de métrica for transmitida durante um período, essa métrica não será emitida durante esse período. Se você interromper o fluxo de métricas, essa métrica deixará de ser emitida até que o fluxo de métricas seja iniciado outra vez. Estatística válida: `Sum` Unidades: nenhuma |
| `TotalMetricUpdate` | Isso é calculado como **MetricUpdate \$1 um número baseado em estatísticas adicionais que estão sendo transmitidas**. Para cada combinação exclusiva de namespace e nome da métrica, a transmissão de 1 a 5 estatísticas adicionais acrescenta 1 a `TotalMetricUpdate`, a transmissão de 6 a 10 estatísticas adicionais acrescenta 2 a `TotalMetricUpdate`, e assim por diante. Estatística válida: `Sum` Unidades: nenhuma |
| `PublishErrorRate` | O número de erros irrecuperáveis que ocorrem ao inserir dados no fluxo de entrega do Firehose. Se não ocorrer nengum erro durante um período, essa métrica não será emitida durante esse período. Se você interromper o fluxo de métricas, essa métrica deixará de ser emitida até que o fluxo de métricas seja iniciado outra vez. Estatística válida: `Average` para ver a taxa de atualizações métricas que não podem ser gravadas. Esse valor deverá ser entre 0.0 e 1.0. Unidades: nenhuma |
# Confiança entre o CloudWatch e o Firehose
O fluxo de entrega do Firehose deve confiar no CloudWatch por meio de um perfil do IAM que tenha permissões de gravação no Firehose. Essas permissões podem ser limitadas ao único fluxo de entrega do Firehose usado pelo fluxo de métricas do CloudWatch. A função do IAM deve confiar no serviço principal `streams.metrics.cloudwatch.amazonaws.com`.
Se usar o console do CloudWatch para criar um fluxo de métricas, você poderá fazer com que o CloudWatch crie a função com as permissões corretas. Caso use outro método para criar um fluxo de métricas ou queira criar a própria função do IAM, ele deverá conter a seguinte política de permissões e política de confiança.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Effect": "Allow",
"Resource": "arn:aws:firehose:us-east-1:123456789012:deliverystream/*"
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "streams.metrics.cloudwatch.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Os dados de métrica são transmitidos pelo CloudWatch ao fluxo de entrega do Firehose de destino em nome da origem que contém o recurso de fluxo de métricas.
# Saída do fluxo de métricas do CloudWatch no formato JSON
Em um fluxo de métricas do CloudWatch que usa o formato JSON, cada registro do Firehose contém vários objetos JSON separados por um caractere de nova linha (\$1n). Cada objeto contém um único ponto de dados de uma única métrica.
O formato JSON usado é totalmente compatível com o AWS Glue e com o Amazon Athena. Se você tiver um fluxo de entrega do Firehose e uma tabela do AWS Glue formatada corretamente, o formato poderá ser automaticamente transformado em Parquet ou em colunar de linha otimizado (ORC) antes de ser armazenado no S3. Para obter mais informações sobre como transformar o formato, consulte [Converting Your Input Record Format in Firehose](https://docs.aws.amazon.com/firehose/latest/dev/record-format-conversion.html). Para obter mais informações sobre o formatos correto para AWS Glue, consulte [Que esquema do AWS Glue devo usar para o formato de saída JSON?](#CloudWatch-metric-streams-format-glue).
No formato JSON, os valores válidos para `unit` são os mesmos que para o valor de `unit` na estrutura da API `MetricDatum`. Para obter mais informações, consulte [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html). O valor do campo `timestamp` está em milissegundos epoch, como `1616004674229`.
O exemplo a seguir é do formato. Neste exemplo, o JSON está formatado para facilitar a leitura, mas, na prática, todo o formato está em uma única linha.
```
{
"metric_stream_name": "MyMetricStream",
"account_id": "1234567890",
"region": "us-east-1",
"namespace": "AWS/EC2",
"metric_name": "DiskWriteOps",
"dimensions": {
"InstanceId": "i-123456789012"
},
"timestamp": 1611929698000,
"value": {
"count": 3.0,
"sum": 20.0,
"max": 18.0,
"min": 0.0,
"p99": 17.56,
"p99.9": 17.8764,
"TM(25%:75%)": 16.43
},
"unit": "Seconds"
}
```
## Que esquema do AWS Glue devo usar para o formato de saída JSON?
Veja a seguir um exemplo de uma representação JSON do `StorageDescriptor` para uma tabela do AWS Glue, que seria usada pelo Firehose. Para obter mais informações sobre `StorageDescriptor`, consulte [ StorageDescriptor](https://docs.aws.amazon.com/glue/latest/webapi/API_StorageDescriptor.html).
```
{
"Columns": [
{
"Name": "metric_stream_name",
"Type": "string"
},
{
"Name": "account_id",
"Type": "string"
},
{
"Name": "region",
"Type": "string"
},
{
"Name": "namespace",
"Type": "string"
},
{
"Name": "metric_name",
"Type": "string"
},
{
"Name": "timestamp",
"Type": "timestamp"
},
{
"Name": "dimensions",
"Type": "map"
},
{
"Name": "value",
"Type": "struct"
},
{
"Name": "unit",
"Type": "string"
}
],
"Location": "s3://amzn-s3-demo-bucket/",
"InputFormat": "org.apache.hadoop.mapred.TextInputFormat",
"OutputFormat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"SerdeInfo": {
"SerializationLibrary": "org.apache.hive.hcatalog.data.JsonSerDe"
},
"Parameters": {
"classification": "json"
}
}
```
O exemplo anterior serve para dados gravados no Amazon S3 no formato JSON. Substitua os valores nos campos a seguir pelos valores indicados para armazenar os dados no formato Parquet ou no formato colunar de linha otimizado (ORC).
+ **Parquet:**
+ inputFormat: org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat
+ outputFormat: org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat
+ SerDeInfo.serializationLib: org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe
+ parameters.classification: parquet
+ **ORC:**
+ inputFormat: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+ outputFormat: org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat
+ SerDeInfo.serializationLib: org.apache.hadoop.hive.ql.io.orc.OrcSerde
+ parameters.classification: orc
# Saída do fluxo de métricas do CloudWatch no formato OpenTelemetry 1.0.0
**nota**
Com o formato OpenTelemetry 1.0.0, os atributos de métricas são codificados como uma lista de objetos `KeyValue` em vez do tipo `StringKeyValue` usado no formato 0.7.0. Como consumidor, essa é a única grande mudança entre os formatos 0.7.0 e 1.0.0. Um analisador gerado nos arquivos de protocolo do 0.7.0 não analisará atributos de métricas codificados no formato 1.0.0. O mesmo acontece ao contrário: um analisador gerado nos arquivos de protocolo do 1.0.0 não analisará atributos de métricas codificados no formato 0.7.0.
OpenTelemetry é uma coleção de ferramentas, APIs e SDKs. Pode ser usada para instrumentar, gerar, coletar e exportar dados de telemetria (métricas, logs e rastreamentos) para análise. O OpenTelemetry faz parte da Cloud Native Computing Foundation. Para obter mais informações, consulte [OpenTelemetry](https://opentelemetry.io/).
Para obter informações sobre a especificação completa do OpenTelemetry 1.0.0, consulte [Release version 1.0.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v1.0.0).
Um registro do Kinesis pode conter uma ou mais estruturas de dados `ExportMetricsServiceRequest` do OpenTelemetry. Cada estrutura de dados começa com um cabeçalho com `UnsignedVarInt32`indicando o tamanho do registro em bytes. Cada `ExportMetricsServiceRequest` pode conter dados de várias métricas ao mesmo tempo.
Veja a seguir uma representação de string da mensagem da estrutura de dados `ExportMetricsServiceRequest` do OpenTelemetry. O OpenTelemetry serializa o uso do protocolo binário do Google Protocol Buffers, e não é legível por humanos.
```
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"
}
}
}
}
}
}
}
}
}
}
```
**Objeto de nível superior para serializar dados de métrica do OpenTelemetry**
`ExportMetricsServiceRequest` é o wrapper de nível mais alto para serializar uma carga útil do exportador do OpenTelemetry. Contém um ou mais `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` é o objeto de nível superior para representar objetos MetricData.
```
// 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;
}
```
**O objeto Resource**
`Resource` é um objeto de par de valor que contém algumas informações sobre o recurso que gerou as métricas. Para métricas criadas pela AWS, a estrutura de dados contém o nome do recurso da Amazon (ARN) do recurso relacionado à métrica, como uma instância do EC2 ou um bucket do S3.
O objeto `Resource` contém um atributo chamado `attributes`, que armazena uma lista de pares de chave-valor.
+ `cloud.account.id` contém o ID da conta
+ `cloud.region` contém a Região
+ `aws.exporter.arn` contém o ARN do fluxo de métricas
+ `cloud.provider` é sempre `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;
}
```
**O objeto ScopeMetrics**
O campo `scope` não será preenchido. Preencheremos apenas o campo de métricas que estamos exportando.
```
// 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;
}
```
**O objeto Metric**
O objeto de métricas contém alguns metadados e um campo de dados `Summary` que contém uma lista de `SummaryDataPoint`.
Para fluxos de métricas, os metadados são:
+ `name` será `amazonaws.com/metric_namespace/metric_name`
+ `description` ficará em branco
+ `unit` será preenchido mapeando a unidade do dado métrico para a variante que distingue maiúsculas e minúsculas do código unificado para unidades de medida. Para obter mais informações, consulte [Conversões com o formato OpenTelemetry 1.0.0 no CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation-100.md) e [Código unificado para unidades de medida](https://ucum.org/ucum.html).
+ `type` O será `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;
}
```
**O objeto SummaryDataPoint**
O objeto SummaryDataPoint contém o valor de um único ponto de dados em uma série temporal em uma métrica DoubleSummary.
```
// 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;
}
```
Para obter mais informações, consulte [Conversões com o formato OpenTelemetry 1.0.0 no CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation-100.md).
# Conversões com o formato OpenTelemetry 1.0.0 no CloudWatch
O CloudWatch executa algumas transformações para colocar os dados do CloudWatch no formato OpenTelemetry.
**Converter namespace, nome da métrica e dimensões**
Esses atributos são pares chave-valor codificados no mapeamento.
+ Um atributo tem a chave `Namespace` e seu valor é o namespace da métrica
+ Um atributo tem a chave `MetricName` e seu valor é o nome da métrica
+ Um par tem a chave `Dimensions` e seu valor é uma lista aninhada de pares de chave/valor. Cada par nessa lista é mapeado para uma dimensão de métrica do CloudWatch, em que a chave do par é o nome da dimensão e seu valor é o valor da dimensão.
**Converter Average, Sum, SampleCount, Min e Max**
O ponto de dados Summary permite que o CloudWatch exporte todas essas estatísticas usando um ponto de dados.
+ `startTimeUnixNano` contém o do CloudWatch `startTime`
+ `timeUnixNano` contém o do CloudWatch `endTime`
+ `sum` contém a estatística Sum.
+ `count` contém a estatística SampleCount.
+ `quantile_values` contém dois objetos `valueAtQuantile.value`:
+ `valueAtQuantile.quantile = 0.0` com `valueAtQuantile.value = Min value`
+ `valueAtQuantile.quantile = 0.99` com `valueAtQuantile.value = p99 value`
+ `valueAtQuantile.quantile = 0.999` com `valueAtQuantile.value = p99.9 value`
+ `valueAtQuantile.quantile = 1.0` com `valueAtQuantile.value = Max value`
Os recursos que consomem o fluxo de métrica podem calcular a estatística Average como **Sum/SampleCount**.
**Converter unidades**
As unidades do CloudWatch são mapeadas para a variante que diferencia maiúsculas de minúsculas do Código unificado para unidades de medida, conforme exibido na tabela a seguir. Para obter mais informações, consulte [Código unificado para unidades de medida](https://ucum.org/ucum.html).
| CloudWatch | OpenTelemetry |
| --- | --- |
| Segunda | s |
| Segundo ou segundos | s |
| Microssegundos | us |
| Milissegundos | ms |
| Bytes | By |
| Kilobytes | kBy |
| Megabytes | MBy |
| Gigabytes | GBy |
| Terabytes | TBy |
| Bits | bit |
| Kilobits | kbit |
| Megabits | MBit |
| Gigabits | Gbit |
| Terabits | Tbit |
| Percentual | % |
| Contagem | \$1Count\$1 |
| Nenhum | 1 |
As unidades que são combinadas com uma barra são mapeadas aplicando-se a conversão do OpenTelemetry de ambas as unidades. Por exemplo, bytes/segundo é mapeado para by/s.
# Como analisar mensagens do OpenTelemetry 1.0.0
Esta seção fornece informações para ajudar você a começar a analisar o OpenTelemetry 1.0.0.
Primeiro, é necessário obter associações específicas de idioma que permitem analisar mensagens do OpenTelemetry 1.0.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. Faça o download das definições de buffers de protocolo (ProtoBuf) do OpenTelemetry 1.0.0 na página [Release version 1.0.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v1.0.0).
1. Confirme que você está na pasta raiz das definições de buffers de protocolo (ProtoBuf) do OpenTelemetry 1.0.0 baixadas. 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|ExportMetricsService...
------ --------------------------- ------ -----------------------
*/
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\$1**
Use `CodedInputStream`. Essa classe é capaz de ler mensagens delimitadas por tamanho.
**C\$1\$1**
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.
# Saída do fluxo de métricas do CloudWatch no formato OpenTelemetry 0.7.0
OpenTelemetry é uma coleção de ferramentas, APIs e SDKs. Pode ser usada para instrumentar, gerar, coletar e exportar dados de telemetria (métricas, logs e rastreamentos) para análise. O OpenTelemetry faz parte da Cloud Native Computing Foundation. Para obter mais informações, consulte [OpenTelemetry](https://opentelemetry.io/).
Para obter informações sobre a especificação completa do OpenTelemetry 0.7.0, consulte a [versão v0.7.0](https://github.com/open-telemetry/opentelemetry-proto/releases/tag/v0.7.0).
Um registro do Kinesis pode conter uma ou mais estruturas de dados `ExportMetricsServiceRequest` do OpenTelemetry. Cada estrutura de dados começa com um cabeçalho com `UnsignedVarInt32`indicando o tamanho do registro em bytes. Cada `ExportMetricsServiceRequest` pode conter dados de várias métricas ao mesmo tempo.
Veja a seguir uma representação de string da mensagem da estrutura de dados `ExportMetricsServiceRequest` do OpenTelemetry. O OpenTelemetry serializa o uso do protocolo binário do Google Protocol Buffers, e não é legível por humanos.
```
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
}
}
}
}
}
}
```
**Objeto de nível superior para serializar dados de métrica do OpenTelemetry**
`ExportMetricsServiceRequest` é o wrapper de nível mais alto para serializar uma carga útil do exportador do OpenTelemetry. Contém um ou mais `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` é o objeto de nível superior para representar objetos 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;
}
```
**O objeto Resource**
`Resource` é um objeto de par de valor que contém algumas informações sobre o recurso que gerou as métricas. Para métricas criadas pela AWS, a estrutura de dados contém o nome do recurso da Amazon (ARN) do recurso relacionado à métrica, como uma instância do EC2 ou um bucket do S3.
O objeto `Resource` contém um atributo chamado `attributes`, que armazena uma lista de pares de chave-valor.
+ `cloud.account.id` contém o ID da conta
+ `cloud.region` contém a Região
+ `aws.exporter.arn` contém o ARN do fluxo de métricas
+ `cloud.provider` é sempre `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;
}
```
**O objeto InstrumentationLibraryMetrics**
O campo instrumentation\$1library não será preenchido. Preencheremos apenas o campo de métricas que estamos exportando.
```
// 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;
}
```
**O objeto Metric**
O objeto de métrica contém um campo de dados `DoubleSummary` que contém uma lista 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;
}
```
**O objeto MetricDescriptor**
O objeto MetricDescriptor contém metadados. Para obter mais informações, consulte o [metrics.proto](https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/metrics/v1/metrics.proto#L110) no GitHub.
Para fluxos de métricas, o MetricDescriptor tem o seguinte conteúdo:
+ `name` O será `amazonaws.com/metric_namespace/metric_name`
+ `description` ficará em branco.
+ `unit` será preenchido mapeando a unidade do dado métrico para a variante que distingue maiúsculas e minúsculas do código unificado para unidades de medida. Para obter mais informações, consulte [Conversões com o formato OpenTelemetry 0.7.0 no CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation.md) e [Código unificado para unidades de medida](https://ucum.org/ucum.html).
+ `type` O será `SUMMARY`.
**O objeto DoubleSummaryDataPoint**
O objeto DoubleSummaryDataPoint contém o valor de um único ponto de dados em uma série temporal em uma métrica DoubleSummary.
```
// 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;
}
```
Para obter mais informações, consulte [Conversões com o formato OpenTelemetry 0.7.0 no CloudWatch](CloudWatch-metric-streams-formats-opentelemetry-translation.md).
# Conversões com o formato OpenTelemetry 0.7.0 no CloudWatch
O CloudWatch executa algumas transformações para colocar os dados do CloudWatch no formato OpenTelemetry.
**Converter namespace, nome da métrica e dimensões**
Esses atributos são pares chave-valor codificados no mapeamento.
+ Um par contém o namespace da métrica
+ Um par contém o nome da métrica
+ Para cada dimensão, o CloudWatch armazena o seguinte par: `metricDatum.Dimensions[i].Name, metricDatum.Dimensions[i].Value`
**Converter Average, Sum, SampleCount, Min e Max**
O ponto de dados Summary permite que o CloudWatch exporte todas essas estatísticas usando um ponto de dados.
+ `startTimeUnixNano` contém o do CloudWatch `startTime`
+ `timeUnixNano` contém o do CloudWatch `endTime`
+ `sum` contém a estatística Sum.
+ `count` contém a estatística SampleCount.
+ `quantile_values` contém dois objetos `valueAtQuantile.value`:
+ `valueAtQuantile.quantile = 0.0` com `valueAtQuantile.value = Min value`
+ `valueAtQuantile.quantile = 0.99` com `valueAtQuantile.value = p99 value`
+ `valueAtQuantile.quantile = 0.999` com `valueAtQuantile.value = p99.9 value`
+ `valueAtQuantile.quantile = 1.0` com `valueAtQuantile.value = Max value`
Os recursos que consomem o fluxo de métrica podem calcular a estatística Average como **Sum/SampleCount**.
**Converter unidades**
As unidades do CloudWatch são mapeadas para a variante que diferencia maiúsculas de minúsculas do Código unificado para unidades de medida, conforme exibido na tabela a seguir. Para obter mais informações, consulte [Código unificado para unidades de medida](https://ucum.org/ucum.html).
| CloudWatch | OpenTelemetry |
| --- | --- |
| Segunda | s |
| Segundo ou segundos | s |
| Microsecond | us |
| Milissegundos | ms |
| Bytes | By |
| Kilobytes | kBy |
| Megabytes | MBy |
| Gigabytes | GBy |
| Terabytes | TBy |
| Bits | bit |
| Kilobits | kbit |
| Megabits | MBit |
| Gigabits | Gbit |
| Terabits | Tbit |
| Percentual | % |
| Contagem | \$1Count\$1 |
| Nenhum | 1 |
As unidades que são combinadas com uma barra são mapeadas aplicando-se a conversão do OpenTelemetry de ambas as unidades. Por exemplo, bytes/segundo é mapeado para by/s.
# 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\$1**
Use `CodedInputStream`. Essa classe é capaz de ler mensagens delimitadas por tamanho.
**C\$1\$1**
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.
# Solução de problemas relacionados aos fluxos de métricas no CloudWatch
Caso não esteja vendo dados de métrica no destino final, confira o seguinte:
+ Confira se o fluxo de métricas está no estado de execução. Para obter etapas sobre como usar o console do CloudWatch para isso, consulte [Operação e manutenção do fluxo de métricas](CloudWatch-metric-streams-operation.md).
+ Métricas publicadas há mais de dois dias não são transmitidas. Para determinar se uma determinada métrica será transmitida, exiba-a em um gráfico no console do CloudWatch e verifique há quanto tempo o último ponto de dados visível ocorreu. Se isso tiver ocorrido há mais de dois dias, ela não será coletada pelas transmissões de métricas.
+ Confira as métricas emitidas pelo fluxo de métricas. No console do CloudWatch, em **Métricas**, veja o namespace **AWS/CloudWatch/MetricStreams** para as métricas **MetricUpdate**, **TotalMetricUpdate** e **PublishErrorRate**.
+ Se a métrica **PublishErrorRate** for alta, confirme se o destino usado pelo fluxo de entrega do Firehose existe e se o perfil do IAM especificado na configuração do fluxo de métricas concede à entidade principal do serviço do `CloudWatch` permissões para gravar nele. Para obter mais informações, consulte [Confiança entre o CloudWatch e o Firehose](CloudWatch-metric-streams-trustpolicy.md).
+ Verifique se o fluxo de entrega do Firehose tem permissão para gravar no destino final.
+ No console do Firehose, exiba o fluxo de entrega do Firehose usado para o fluxo de métricas e verifique a aba **Monitoramento** para ver se o fluxo de entrega do Firehose está recebendo dados.
+ Confirme se configurou o fluxo de entrega do Firehose com os detalhes corretos.
+ Confira todos os logs ou métricas disponíveis do destino final de gravação do fluxo de entrega do Firehose.
+ Para obter informações mais detalhadas, habilite o registro de erros em log do CloudWatch Logs no fluxo de entrega do Firehose. Para obter mais informações, consulte [Monitorar o Amazon Data Firehose usando o CloudWatch Logs](https://docs.aws.amazon.com/firehose/latest/dev/monitoring-with-cloudwatch-logs.html).
**nota**
Após o envio de um ponto de dados para uma métrica e um carimbo de data/hora específicos, ele não será enviado novamente, mesmo que o valor do ponto de dados mude posteriormente.