# CloudWatch RUM
<a name="CloudWatch-RUM"></a>

Com o CloudWatch RUM, você pode realizar o monitoramento de usuários reais para coletar e visualizar dados do lado do cliente sobre a performance de aplicações Web em sessões de usuário reais, praticamente em tempo real. Em aplicações Web, você pode analisar os tempos de carregamento de páginas, os erros no lado do cliente e o comportamento dos usuários. Em aplicações móveis, você pode monitorar os tempos de carregamento de tela, os tempos de inicialização da aplicação, erros de rede, panes e problemas específicos da plataforma, como aplicação Android não responsiva (ANR) e congelamentos de aplicação iOS. Ao visualizar esses dados, é possível vê-los agregados ou detalhados por tipos de dispositivo, sistemas operacionais e outras características do seu uso da aplicação.

Você pode usar os dados coletados para identificar e depurar rapidamente problemas de performance do lado do cliente. O CloudWatch RUM ajuda a visualizar anomalias na performance da aplicação e encontrar dados de depuração relevantes, como mensagens de erro, rastreamentos de pilha e sessões de usuário. Você também pode usar o RUM para entender o alcance do impacto para o usuário final, incluindo o número de usuários, áreas geográficas e navegadores usados.

Os dados do usuário final coletados para o CloudWatch RUM são retidos por 30 dias e, em seguida, excluídos automaticamente. Se quiser manter os eventos do RUM por mais tempo, o monitor de aplicações poderá enviar cópias dos eventos para o CloudWatch Logs em sua conta. Em seguida, você pode ajustar o período de retenção para esse grupo de logs.

Para usar o RUM, crie um *app monitor* (monitor de aplicações) e insira algumas informações. O RUM gera um trecho de código que você pode usar para adicionar uma injeção de dependências na aplicação. O trecho de código extrai o código do cliente do RUM conforme necessário. O cliente do RUM captura dados de uma porcentagem das sessões de usuário da aplicação, o que é exibido em um painel pré-compilado. Você pode especificar a porcentagem de sessões de usuário da qual coletar dados.

 O CloudWatch RUM é integrado ao [Application Signals](CloudWatch-Application-Monitoring-Sections.md), que pode descobrir e monitorar serviços das suas aplicações, clientes, canários do Synthetics e dependências de serviços. Use o Application Signals para ver uma lista ou um mapa visual dos seus serviços, visualizar métricas de integridade com base nos seus objetivos de nível de serviço (SLOs) e fazer uma busca profunda para ver rastreamentos do X-Ray correlacionados para uma solução de problemas mais detalhada. Para ver as solicitações de página do cliente do RUM no Application Signals, ative o rastreamento ativo do X-Ray criando um [monitor de aplicações](CloudWatch-RUM-get-started-create-app-monitor.md). Para aplicações Web, você também pode habilitar isso [configurando manualmente o cliente Web do RUM](CloudWatch-RUM-configure-client.md). Os clientes RUM são exibidos no [Mapa da aplicação](ServiceMap.md) conectado aos serviços e na página [Detalhes do serviço](ServiceDetail.md) dos serviços que eles chamam. 

Os clientes do RUM são código aberto. Para saber mais, consulte o [cliente Web do CloudWatch RUM](https://github.com/aws-observability/aws-rum-web), o [SDK do AWS Distro for OpenTelemetry (ADOT) para Android](https://github.com/aws-observability/aws-otel-android) e o [SDK do AWS Distro for OpenTelemetry (ADOT) para iOS](https://github.com/aws-observability/aws-otel-swift).

**Definição de preço do RUM**

Para obter informações sobre preços, consulte [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/). 

**Disponibilidade de regiões**

No momento, o CloudWatch RUM está disponível nas seguintes regiões:
+ Leste dos EUA (Norte da Virgínia)
+ Leste dos EUA (Ohio)
+ Oeste dos EUA (N. da Califórnia)
+ Oeste dos EUA (Oregon)
+ África (Cidade do Cabo)
+ AWS GovCloud (Leste dos EUA)
+ AWS GovCloud (Oeste dos EUA)
+ Ásia-Pacífico (Mumbai)
+ Ásia-Pacífico (Hyderabad)
+ Ásia-Pacífico (Melbourne)
+ Ásia-Pacífico (Osaka)
+ Ásia-Pacífico (Seul)
+ Ásia-Pacífico (Singapura)
+ Ásia-Pacífico (Sydney)
+ Ásia-Pacífico (Jacarta)
+ Ásia-Pacífico (Malásia)
+ Ásia-Pacífico (Tailândia)
+ Ásia-Pacífico (Tóquio)
+ Ásia-Pacífico (Hong Kong)
+ Canadá (Central)
+ Europa (Frankfurt)
+ Europa (Irlanda)
+ Europa (Londres)
+ Europa (Milão)
+ Europe (Paris)
+ Europa (Espanha)
+ Europa (Estocolmo)
+ Europa (Zurique)
+ AWS European Sovereign Cloud (Alemanha)
+ Oriente Médio (Bahrein)
+ Oriente Médio (Emirados Árabes Unidos)
+ México (Centro)
+ América do Sul (São Paulo)
+ Israel (Tel Aviv)
+ Oeste do Canadá (Calgary)

# Configurar uma aplicação móvel para usar o CloudWatch RUM
<a name="CloudWatch-RUM-web-mobile"></a>

Para monitorar aplicações móveis, crie um monitor de aplicações, configure-o para plataformas móveis e integre o SDK do AWS Distro for OpenTelemetry (ADOT) com a aplicação. O Mobile RUM usa o protocolo OpenTelemetry (OTLP) para enviar dados de telemetria a um endpoint OTLP dedicado. 

## Para criar um monitor de aplicações para uma plataforma móvel
<a name="mobile-platform-app-monitor"></a>

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha **Add app monitor** (Adicionar monitor de aplicações).

1. Em **App monitor name** (Nome do monitor de aplicações), insira um nome a ser usado para identificar esse monitor de aplicações no console do CloudWatch RUM.

1. Selecione **Android** ou **iOS** como plataforma.

1. Em **Armazenamento de dados**, é possível armazenar cópias dos eventos de log e intervalos do RUM OTEL no CloudWatch Logs e configurar a retenção. Por padrão, o grupo de logs do CloudWatch Logs retém os dados por 30 dias. Você pode ajustar seu período de retenção de logs no console de Logs do CloudWatch.

1. (Opcional) Em **Política baseada no recurso**, escolha adicionar uma política baseada em recursos para controlar quem pode enviar solicitações ao monitor de aplicações. Se você escolher **Criar política pública**, uma política de recurso será anexada para permitir que qualquer pessoa envie solicitações ao monitor de aplicações. Para obter mais informações, consulte [Usar políticas baseadas em recursos com o CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

1. Para habilitar o rastreamento do AWS X-Ray das sessões de usuário incluídas na amostragem, escolha **Rastreamento ativo** e selecione **Rastrear o serviço com o AWS**.

   Se selecionado, os intervalos de OTEL gerados durante as sessões de usuário incluídas na amostragem serão rastreados. Você pode visualizar os rastros e intervalos dessas sessões de usuário no painel do RUM, no mapa de rastro e nas páginas de detalhes de rastro do X-Ray. Essas sessões de usuário também aparecerão como páginas de clientes no Application Signals depois que você as tiver habilitado para a aplicação.

1. (Opcional) Você pode adicionar tags ao monitor de aplicações:

   1. Em **Tags**, escolha **Adicionar nova tag**.

   1. Em **Chave**, insira um nome para a tag. É possível adicionar um valor opcional em **Valor**.

   1. Para adicionar outra tag, escolha novamente **Adicionar nova tag**.

   Para saber mais, consulte [Marcar recursos da AWS](https://docs.aws.amazon.com/tagging/latest/userguide/tagging-resources.html) no *Guia do usuário de marcação e do editor de tags da AWS*.

1. Escolha **Add app monitor** (Adicionar monitor de aplicações).

1. Na seção **Exemplo de código**, é possível copiar o trecho de código para adicioná-lo à aplicação. **Usando o SDK do AWS Distro for OpenTelemetry (ADOT), você pode escolher entre **instrumentação manual** para configurar o monitoramento no código da aplicação ou instrumentação de código zero** que requer alterações mínimas na configuração.

   Para aplicações Android e iOS, a instrumentação de código zero é a opção mais simples, pois inicializa automaticamente a coleta de telemetria usando um arquivo de configuração. A instrumentação manual permite maior controle do processo de inicialização e configuração.

1. Escolha **Copy** (Copiar) ou **Download** (Fazer download) e, em seguida, escolha **Done** (Pronto).

### Configuração de aplicação iOS
<a name="CloudWatch-RUM-ios-setup"></a>

Para aplicações iOS, integre o [SDK do AWS Distro for OpenTelemetry (ADOT) para iOS](https://github.com/aws-observability/aws-otel-swift) para habilitar o monitoramento RUM. O SDK é compatível com o iOS 16 e versões posteriores e fornece instrumentação automática para os cenários de performance usuais.

### Configuração de aplicações Android
<a name="CloudWatch-RUM-android-setup"></a>

Para aplicações Android, integre o [SDK do AWS Distro for OpenTelemetry (ADOT) para Android](https://github.com/aws-observability/aws-otel-android) para habilitar o monitoramento RUM. O SDK fornece instrumentação automática e é compatível com modelos de autenticação assinados e não assinados.

## Autenticação e segurança
<a name="CloudWatch-RUM-authentication"></a>

O Mobile RUM é compatível com modelos de autenticação flexíveis, conforme definido em seus SDKs.
+ As aplicações iOS usam o [SDK do AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-swift) para iOS. 
+ As aplicações Adroid usam o [SDK do AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android) para Android.

# Políticas do IAM para uso do CloudWatch RUM
<a name="CloudWatch-RUM-permissions"></a>

Para poder gerenciar totalmente o CloudWatch RUM, você deve estar conectado como um usuário do IAM ou função que tenha uma Política do IAM **AmazonCloudWatchRUMFullAccess**. Além disso, podem ser necessárias outras políticas ou permissões:
+ Para criar um monitor de aplicações que gere um novo grupo de identidades do Amazon Cognito para autorização, você precisa ter a função do IAM **Admin** ou a política do IAM **AdministratorAccess**.
+ Para criar um monitor de aplicações que envie dados para o CloudWatch Logs, você deve estar conectado a uma função ou política do IAM que tenha a seguinte permissão:

  ```
  {
      "Effect": "Allow",
      "Action": [
          "logs:PutResourcePolicy"
      ],
      "Resource": [
          "*"
      ]
  }
  ```
+ Para habilitar os mapas de origem do JavaScript em um monitor de aplicação, você precisará fazer upload dos seus arquivos de mapa de origem para um bucket do Amazon S3. Seu perfil ou política do IAM precisa de permissões específicas do Amazon S3 que permitam criar buckets do Amazon S3, definir políticas de bucket e gerenciar arquivos no bucket. Por motivos de segurança, limite essas permissões a recursos específicos. O exemplo de política abaixo restringe o acesso aos buckets que contenham `rum` em seus respectivos nomes e usa a chave de condição `aws:ResourceAccount` para limitar as permissões somente à conta da entidade principal.

  ```
  {
      "Sid": "AllowS3BucketCreationAndListing",
      "Effect": "Allow",
      "Action": [
          "s3:CreateBucket",
          "s3:ListAllMyBuckets"
      ],
      "Resource": "arn:aws:s3:::*",
      "Condition": {
          "StringEquals": {
              "aws:ResourceAccount": "${aws:PrincipalAccount}"
          }
      }
  },
  {
      "Sid": "AllowS3BucketActions",
      "Effect": "Allow",
      "Action": [
          "s3:GetBucketLocation",
          "s3:ListBucket"
      ],
      "Resource": "arn:aws:s3:::*rum*",
      "Condition": {
          "StringEquals": {
              "aws:ResourceAccount": "${aws:PrincipalAccount}"
          }
      }
  },
  {
      "Sid": "AllowS3BucketPolicyActions",
      "Effect": "Allow",
      "Action": [
          "s3:PutBucketPolicy",
          "s3:GetBucketPolicy"
      ],
      "Resource": "arn:aws:s3:::*rum*",
      "Condition": {
          "StringEquals": {
              "aws:ResourceAccount": "${aws:PrincipalAccount}"
          }
      }
  },
  {
      "Sid": "AllowS3ObjectActions",
      "Effect": "Allow",
      "Action": [
          "s3:GetObject",
          "s3:PutObject",
          "s3:DeleteObject",
          "s3:AbortMultipartUpload"
      ],
      "Resource": "arn:aws:s3:::*rum*",
      "Condition": {
          "StringEquals": {
              "aws:ResourceAccount": "${aws:PrincipalAccount}"
          }
      }
  }
  ```
+ Para usar suas próprias chaves do AWS KMS para criptografia no lado do servidor em seu bucket de mapas de origem, seu perfil ou política do IAM precisará de permissões específicas do AWS KMS que permitam criar uma chave, atualizar a política de chaves, usar a chave do AWS KMS com o Amazon S3 e definir a configuração de criptografia do seu bucket do Amazon S3. Por motivos de segurança, limite essas permissões a propósitos específicos. O exemplo abaixo restringe o acesso às chaves de uma região e accountId específicos e tem restrições do S3 semelhantes às do exemplo acima. 

  ```
  {
      "Sid": "AllowKMSKeyCreation",
      "Effect": "Allow",
      "Action": [
          "kms:CreateKey",
          "kms:CreateAlias"
      ],
      "Resource": "*"
  },
  {
      "Sid": "KMSReadPermissions",
      "Effect": "Allow",
      "Action": [
          "kms:ListAliases"
      ],
      "Resource": "*"
  },
  {
      "Sid": "AllowUpdatingKeyPolicy",
      "Effect": "Allow",
      "Action": [
          "kms:PutKeyPolicy",
          "kms:GetKeyPolicy",
          "kms:ListKeyPolicies"
      ],
      "Resource": "arn:aws:kms:REGION:ACCOUNT_ID:key/*"
  },
  {
      "Sid": "AllowUseOfKMSKeyForS3",
      "Effect": "Allow",
      "Action": [
          "kms:DescribeKey",
          "kms:Encrypt",
          "kms:Decrypt",
          "kms:GenerateDataKey"
      ],
      "Resource": "arn:aws:kms:REGION:ACCOUNT_ID:key/*"
  },
  {
      "Sid": "AllowS3EncryptionConfiguration",
      "Effect": "Allow",
      "Action": [
          "s3:PutEncryptionConfiguration",
          "s3:GetEncryptionConfiguration"
      ],
      "Resource": "arn:aws:s3:::*rum*",
      "Condition": {
          "StringEquals": {
              "aws:ResourceAccount": "${aws:PrincipalAccount}"
          }
      }
  }
  ```

Outros usuários que precisam visualizar os dados, mas não necessitam criar recursos do CloudWatch RUM podem receber a política **AmazonCloudWatchRUMReadOnlyAccess**.

# Configurar uma aplicação Web para usar o CloudWatch RUM
<a name="CloudWatch-RUM-get-started"></a>

Siga as etapas nessas seções para configurar a aplicação Web para começar a usar o CloudWatch RUM na coleta de dados de performance de sessões de usuário reais.

**Topics**
+ [Autorizar a aplicação a enviar dados para a AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Criar um monitor de aplicações do CloudWatch RUM para uma aplicação Web](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Modificação do trecho de código para a configuração do cliente Web do CloudWatch RUM (opcional)](CloudWatch-RUM-modify-snippet.md)
+ [Como inserir o trecho de código do monitor de aplicação do CloudWatch na aplicação](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Teste da configuração do monitor de aplicação do CloudWatch ao gerar eventos de usuário](CloudWatch-RUM-get-started-generate-data.md)

# Autorizar a aplicação a enviar dados para a AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Há quatro opções para configurar a autenticação de dados:
+ Usar o Amazon Cognito e deixar o CloudWatch RUM criar um novo banco de identidades do Amazon Cognito para a aplicação. Esse método requer o menor esforço de configuração.

  O grupo de identidades conterá uma identidade não autenticada. Isso permite que o cliente da Web do CloudWatch RUM envie dados para o CloudWatch RUM sem autenticar o usuário da aplicação.

  O grupo de identidades do Amazon Cognito tem uma função do IAM anexada. A identidade não autenticada do Amazon Cognito permite que o cliente da Web assuma a função do IAM autorizada a enviar dados para o CloudWatch RUM.
+ Use o Amazon Cognito para autenticação. Se você fizer isso, poderá usar um banco de identidades existente do Amazon Cognito ou criar um novo para usar com este monitor de aplicações. Se você usar um banco de identidades existente, também deverá modificar o perfil do IAM anexado a esse banco de identidades. Use esta opção para bancos de identidades que oferecem suporte para usuários não autenticados. Você pode usar somente bancos de identidades da mesma região.
+ Use a autenticação de um provedor de identidade existente que você já configurou. Nesse caso, você deve obter credenciais do provedor de identidade e sua aplicação deve encaminhá-las para o cliente da Web do RUM.

  Use esta opção para bancos de identidades que oferecem suporte somente para usuários autenticados.
+ Use políticas baseadas em recursos para gerenciar o acesso ao monitor da aplicação. Isso inclui a capacidade de enviar solicitações não autenticadas para o CloudWatch RUM sem as credenciais da AWS. Para saber mais sobre as políticas baseadas em recursos e o RUM, consulte [Usar políticas baseadas em recursos com o CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

As seções a seguir apresentam mais detalhes sobre essas opções.

## Usar um grupo existente de identidades do Amazon Cognito
<a name="CloudWatch-RUM-get-started-authorization-existingcognito"></a>

Se você optar por usar um banco de identidades do Amazon Cognito, especifique o banco de identidades ao adicionar a aplicação ao CloudWatch RUM. O grupo deve ser compatível com a habilitação do acesso a identidades não autenticadas. Você pode usar somente bancos de identidades da mesma região.

Você também deve adicionar as seguintes permissões à política do IAM anexada à função do IAM associada a esse grupo de identidades.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        { 
            "Effect": "Allow",
            "Action": [
                "rum:PutRumEvents"
            ],
            "Resource": "arn:aws:rum:us-east-1:123456789012:appmonitor/app monitor name" 
        }
    ]
}
```

------

O Amazon Cognito enviará o token de segurança necessário para permitir que sua aplicação acesse o CloudWatch RUM.

## Provedor de terceiros
<a name="CloudWatch-RUM-get-started-authorization-thirdparty"></a>

Se você decidir usar a autenticação privada de um provedor terceirizado, deverá obter credenciais do provedor de identidade e encaminhá-las para a AWS. A melhor maneira de fazer isso é usar um *fornecedor de token de segurança*. Você pode usar qualquer fornecedor de token de segurança, incluindo o Amazon Cognito com o AWS Security Token Service. Para obter mais informações sobre o AWS STS, consulte [Welcome to the AWS Security Token Service API Reference](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). 

Se você quiser usar o Amazon Cognito como fornecedor de token nesse cenário, você pode configurá-lo para trabalhar com um provedor de autenticação. Para obter mais informações, consulte [Conceitos básicos dos grupos de identidades do Amazon Cognito (identidades federadas)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html).

Depois de configurar o Amazon Cognito para trabalhar com seu provedor de identidade, é necessário também fazer o seguinte:
+ Criar uma função do IAM com as permissões a seguir. Sua aplicação usará essa função para acessar a AWS.

------
#### [ JSON ]

****  

  ```
  { 
   "Version":"2012-10-17",		 	 	 
   "Statement": [ 
     { 
       "Effect": "Allow",
       "Action": "rum:PutRumEvents",
       "Resource": "arn:aws:rum:us-east-2:123456789012:appmonitor/AppMonitorName"
     }
   ]
  }
  ```

------
+ Adicione o seguinte à sua aplicação para que ela passe as credenciais do provedor para o CloudWatch RUM. Insira a linha para que ela seja executada depois que um usuário fizer login na aplicação e a aplicação receber as credenciais a serem usadas para acessar a AWS.

  ```
  cwr('setAwsCredentials', {/* Credentials or CredentialProvider */});
  ```

Para obter mais informações sobre provedores de credenciais no SDK JavaScript da AWS, consulte [Definir credenciais em um navegador da Web](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) no guia do desenvolvedor v3 para SDK JavaScript, [Configurar credenciais em um navegador da Web](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) no guia do desenvolvedor v2 para SDK para JavaScript, e [@aws -sdk/credencial-providers](https://www.npmjs.com/package/@aws-sdk/credential-providers). 

Você também pode usar o SDK para o cliente da Web do CloudWatch RUM configurar os métodos de autenticação do cliente da Web. Para obter mais informações sobre o cliente da Web, do SDK, consulte [CloudWatch RUM web client SDK](https://github.com/aws-observability/aws-rum-web). 

# Criar um monitor de aplicações do CloudWatch RUM para uma aplicação Web
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Para começar a usar o CloudWatch RUM com sua aplicação, você cria um *app monitor* (monitor de aplicações). Quando o monitor de aplicações é criado, o RUM gera um trecho de código ser colado na aplicação. O trecho de código importa o código do cliente do RUM. O cliente do RUM captura dados das sessões de usuário da aplicação e os envia ao RUM.

## Para criar um monitor de aplicações para uma plataforma Web
<a name="web-platform-app-monitor"></a>

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha **Add app monitor** (Adicionar monitor de aplicações).

1. Em **App monitor name** (Nome do monitor de aplicações), insira um nome a ser usado para identificar esse monitor de aplicações no console do CloudWatch RUM.

1. Selecione **Web** como plataforma.

1. Em **Domínio da aplicação**, insira os nomes de domínio registrados nos quais sua aplicação tem autoridade administrativa. Você também pode usar um caractere curinga `*` para permitir quaisquer subdomínios ou domínios de nível superior (p. ex., \$1.amazon.com, amazon.\$1, \$1.amazon.\$1).

1. Em **Configure RUM data collection** (Configurar a coleta de dados do RUM), especifique se você deseja que o monitor de aplicações colete cada um dos seguintes dados:
   + **Performance telemetry** (Telemetria de performance) – Coleta informações sobre o carregamento da página e os tempos de carregamento de recursos
   + **Erros de JavaScript** (Erros de JavaScript): coleta informações sobre erros de JavaScript não tratados gerados pela sua aplicação

     Você pode selecionar **Desminificar rastreamentos de pilha de erros de JavaScript** para depurar erros de JavaScript desminificados. Para usar esse recurso, faça upload dos seus arquivos de mapa de origem para um bucket ou pasta do Amazon S3 e informe o URI do Amazon S3. Uma vez ativado, o RUM usará esses mapas de origem e enriquecerá os eventos de erro de JavaScript adicionando o rastreamento de pilha desminificado. Observe que após habilitar esse recurso, ele processará apenas novos eventos de erro de JavaScript e não poderá ser usado em dados coletados anteriormente. Para obter mais informações, consulte [Habilitar a desminificação de rastreamentos de pilha de erros em JavaScript](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **HTTP Errors** (Erros HTTP): coleta informações sobre erros de HTTP lançados pela aplicação

   A seleção dessas opções fornece mais informações sobre sua aplicação, mas também gera mais eventos RUM do CloudWatch e, portanto, incorre em mais cobranças.

   Se você não selecionar nenhuma delas, o monitor de aplicações ainda coletará eventos de início de sessão e IDs de página para que você possa ver quantos usuários estão usando sua aplicação, incluindo falhas por tipo e versão do sistema operacional, tipo e versão do navegador, tipo de dispositivo e localização.

1. Selecione **Check this option to allow the CloudWatch RUM Web Client to set cookies** (Marque esta opção para permitir que o CloudWatch RUM Web Client defina cookies) se quiser coletar IDs de usuário e IDs de sessão de sessões de usuário amostradas. As IDs de usuário são geradas aleatoriamente pelo RUM. Para obter mais informações, consulte [Cookies do cliente da Web do CloudWatch RUM (ou tecnologias semelhantes)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. Em **Sessions sample** (Exemplos de sessão), insira a porcentagem de sessões do usuário que serão usadas para coletar dados do RUM. O padrão é 100%. A redução desse número fornece menos dados, mas diminui suas cobranças. Para obter mais informações sobre a definição de preços do RUM, consulte [Definição de preços do RUM](CloudWatch-RUM.md#RUMpricing).

1. Os dados do usuário final coletados para o CloudWatch RUM são retidos por 30 dias e depois excluídos. Se você quiser manter cópias de eventos RUM no CloudWatch Logs e configurar por quanto tempo reter essas cópias, escolha **Check this option to store your application telemetry data in your CloudWatch Logs account** (Marque esta opção para armazenar os dados de telemetria da aplicação em sua conta do CloudWatch Logs) abaixo de **Data storage** (Armazenamento de dados). Por padrão, o grupo de logs do CloudWatch Logs retém os dados por 30 dias. Você pode ajustar seu período de retenção de logs no console de Logs do CloudWatch.

1. (Opcional) Escolha adicionar uma política baseada em recursos ao monitor da aplicação para controlar quem pode enviar solicitações `PutRumEvents` ao monitor da aplicação. Se você escolher **Criar política pública**, uma política de recursos será anexada ao monitor da aplicação, permitindo que qualquer pessoa envie solicitações `PutRumEvents` ao monitor da aplicação. Para obter mais informações sobre esse método, consulte [Usar políticas baseadas em recursos com o CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

1. Se você anexou uma política baseada no recurso na etapa anterior, não precisará assinar solicitações ao CloudWatch RUM com as credenciais da AWS e poderá pular a configuração da autorização. Caso contrário, em **Autorização**, especifique se deve ser usado um banco de identidades novo ou existente do Amazon Cognito ou se é preciso usar outro provedor de identidades. A criação de um novo grupo de identidades é a opção mais simples, que não requer outras etapas de configuração. Para obter mais informações, consulte [Autorizar a aplicação a enviar dados para a AWS](CloudWatch-RUM-get-started-authorization.md).

   A criação de um novo grupo de identidades do Amazon Cognito requer permissões administrativas. Para obter mais informações, consulte [Políticas do IAM para uso do CloudWatch RUM](CloudWatch-RUM-permissions.md).

1. (Opcional) Por padrão, quando você adiciona o snippet de código RUM à aplicação, o cliente da Web injeta a etiqueta JavaScript para monitorar o uso no código HTML de todas as páginas da aplicação. Para alterar isso, escolha **Configure pages** (Configurar páginas) e, em seguida, escolha **Include only these pages** (Incluir somente essas páginas) ou **Exclude these pages** (Excluir essas páginas). Em seguida, especifique as páginas a serem incluídas ou excluídas. Para especificar uma página a ser incluída ou excluída, insira as URLs completas. Para especificar páginas adicionais, escolha **Add URL** (Adicionar URL).

1. Para habilitar o rastreamento do AWS X-Ray para as sessões de usuário incluídas na amostra obtida pelo monitor de aplicações, escolha **Rastreamento ativo** e selecione **Rastrear meu serviço com o AWS X-Ray**.

   Se você fizer essa seleção, as solicitações `XMLHttpRequest` e `fetch` feitas durante as sessões do usuário amostradas pelo monitor de aplicações serão rastreadas. Você pode visualizar os rastreamentos e segmentos dessas sessões de usuário no painel do RUM e no mapa de rastreamento e nas páginas de detalhes do rastreamento do X-Ray. Essas sessões de usuário também aparecerão como páginas de clientes no [Application Signals](CloudWatch-Application-Monitoring-Sections.md) depois que você as tiver habilitado para a aplicação.

   Ao fazer alterações de configuração adicionais no cliente da Web do CloudWatch RUM, você pode adicionar um cabeçalho de rastreamento do X-Ray às solicitações HTTP para permitir o rastreamento de ponta a ponta das sessões do usuário até o downstream de serviços gerenciados pela AWS. Para obter mais informações, consulte [Habilitar o rastreamento do X-Ray de ponta a ponta](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Opcional) Para adicionar etiquetas ao monitor de aplicações, escolha **Tags** (Etiquetas), **Add new tag** (Adicionar nova etiqueta).

   Em seguida, em **Key** (Chave), insira um nome para a etiqueta. É possível adicionar um valor opcional para a tag em **Valor**. 

   Para adicionar outra etiqueta, escolha novamente **Add new tag** (Adicionar nova etiqueta).

   Para obter mais informações, consulte [Marcar recursos da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).

1. Escolha **Add app monitor** (Adicionar monitor de aplicações).

1. Na seção **Código de exemplo**, é possível copiar o snippet de código a ser usado para adicioná-lo à aplicação. Recomendamos escolher **JavaScript** ou **TypeScript** e usar o NPM para instalar o cliente web CloudWatch RUM como um módulo JavaScript.

   Como alternativa, é possível escolher **HTML** para usar uma rede de entrega de conteúdo (CDN) para instalar o cliente da Web do CloudWatch RUM. A desvantagem de usar uma CDN é que o cliente da Web muitas vezes é bloqueado por bloqueadores de anúncios.

1. Escolha **Copy** (Copiar) ou **Download** (Fazer download) e, em seguida, escolha **Done** (Pronto).

# Modificação do trecho de código para a configuração do cliente Web do CloudWatch RUM (opcional)
<a name="CloudWatch-RUM-modify-snippet"></a>

Você pode modificar o snippet de código antes de inseri-lo em sua aplicação, para ativar ou desativar várias opções. Para obter mais informações, consulte a [ Documentação do cliente da Web do CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).

Existem quatro opções de configuração que você definitivamente deve conhecer, conforme discutido nestas seções.

## Impedir a coleta de URLs de recursos que possam conter informações pessoais
<a name="CloudWatch-RUM-resourceURL"></a>

Por padrão, o cliente da Web do CloudWatch RUM é configurado para registrar as URLs de recursos baixados pela aplicação. Esses recursos incluem arquivos HTML, imagens, arquivos CSS, arquivos JavaScript e assim por diante. Em algumas aplicações, os URLs podem conter informações de identificação pessoal (PII).

Se esse for o caso da sua aplicação, recomendamos que você desabilite a coleção de URLs de recursos definindo `recordResourceUrl: false` na configuração do snippet de código antes de inseri-lo em sua aplicação.

## Registrar visualizações de página manualmente
<a name="CloudWatch-RUM-pageload"></a>

Por padrão, o cliente da Web registra as visualizações de página quando ela é carregada pela primeira vez e quando a API de histórico do navegador é chamada. O ID da página padrão é `window.location.pathname`. No entanto, em alguns casos, talvez você queira substituir esse comportamento e instrumentar a aplicação para registrar visualizações de página de forma programática. Isso permite que você controle o ID da página e quando ele é gravado. Por exemplo, considere uma aplicação da Web que tenha um URI com um identificador de variável, como `/entity/123` ou `/entity/456`. Por padrão, o CloudWatch RUM gera um evento de visualização de página para cada URI com um ID de página distinto correspondente ao nome do caminho, mas talvez você queira agrupá-los pelo mesmo ID de página. Para fazer isso, desative a automação de visualização de página do cliente Web usando a configuração `disableAutoPageView` e use o comando `recordPageView` para definir o ID da página desejada. Para obter mais informações, consulte [Configurações específicas da aplicação](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md) no GitHub.

**Exemplo de script incorporado:**

```
cwr('recordPageView', { pageId: 'entityPageId' });
```

**Exemplo de módulo JavaScript:**

```
awsRum.recordPageView({ pageId: 'entityPageId' });
```

## Habilitar o rastreamento do X-Ray de ponta a ponta
<a name="CloudWatch-RUM-xraytraceheader"></a>

Quando você cria o monitor de aplicações, selecionar **Rastrear meu serviço com o AWS X-Ray** habilita o rastreamento de solicitações de `XMLHttpRequest` e `fetch` feitas durante as sessões de usuário incluídas na amostra obtida pelo monitor de aplicações. Você pode visualizar os rastreamentos dessas solicitações HTTP no painel do RUM e no mapa de rastreamento e nas páginas de detalhes de rastreamento do X-Ray.

Por padrão, esses rastreamentos do lado do cliente não estão conectados a rastreamentos do lado do servidor downstream. Para conectar rastreamentos do lado do cliente a rastreamentos do lado do servidor e habilitar o rastreamento de ponta a ponta, defina a opção `addXRayTraceIdHeader` para `true` no cliente da Web. Isso faz com que o cliente da Web do CloudWatch RUM adicione um cabeçalho de rastreamento do X-Ray às solicitações HTTP.

O bloco de código a seguir mostra um exemplo de adição de rastreamentos do lado do cliente. Algumas opções de configuração são omitidas dessa amostra para oferecer melhor leitura.

```
<script>
    (function(n,i,v,r,s,c,u,x,z){...})(
        'cwr',
        '00000000-0000-0000-0000-000000000000',
        '1.0.0',
        'us-west-2',
        'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
        {
            enableXRay: true,
            telemetries: [ 
                'errors', 
                'performance',
                [ 'http', { addXRayTraceIdHeader: true } ]
            ]
        }
    );
</script>
```

**Atenção**  
Configurar o cliente da Web do CloudWatch RUM para adicionar um cabeçalho de rastreamento do X-Ray às solicitações HTTP pode fazer com que o compartilhamento de recursos de origem cruzada (CORS) falhe ou invalide a assinatura da solicitação, se essa solicitação for assinada com Sigv4. Para obter mais informações, consulte a [ Documentação do cliente da Web do CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md). É altamente recomendável que você teste sua aplicação antes de adicionar um cabeçalho de rastreamento do X-Ray do lado do cliente em um ambiente de produção.

Para obter mais informações consulte a [Documentação do cliente da Web do CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http)

## Enviar solicitações não assinadas para o CloudWatch RUM
<a name="CloudWatch-RUM-unsigned"></a>

Por padrão, o cliente da web do RUM assina todas as solicitações enviadas ao RUM. Se você definir `signing:false` na configuração do cliente, as solicitações não serão assinadas quando forem enviadas para o CloudWatch RUM. Os dados serão ingeridos no RUM somente se houver uma política pública baseada em recursos anexada ao monitor da aplicação. Para obter mais informações, consulte [Usar políticas baseadas em recursos com o CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

# Como inserir o trecho de código do monitor de aplicação do CloudWatch na aplicação
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

Em seguida, insira o snippet de código criado na seção anterior na aplicação.

**Atenção**  
O cliente da Web, baixado e configurado pelo snippet de código, usa cookies (ou tecnologias semelhantes) para ajudar a coletar dados do usuário final. Antes de inserir o snippet do código, consulte [Filtrar por atributos de metadados no consoleProteção de dados e privacidade de dados com o CloudWatch RUM](CloudWatch-RUM-privacy.md).

Se você não tiver o snippet de código gerado anteriormente, poderá encontrá-lo seguindo as instruções no [Como encontro um snippet de código que já gerei?](CloudWatch-RUM-find-code-snippet.md).

**Para inserir o snippet de código RUM do CloudWatch em sua aplicação**

1. Insira o snippet de código que você copiou ou baixou na seção anterior dentro do elemento `<head>` da aplicação. Insira-o antes do elemento `<body>` ou de qualquer outra etiqueta `<script>`.

   O seguinte exemplo mostra um de um snippet de código gerado:

   ```
   <script>
   (function (n, i, v, r, s, c, x, z) {
       x = window.AwsRumClient = {q: [], n: n, i: i, v: v, r: r, c: c};
       window[n] = function (c, p) {
           x.q.push({c: c, p: p});
       };
       z = document.createElement('script');
       z.async = true;
       z.src = s;
       document.head.insertBefore(z, document.getElementsByTagName('script')[0]);
   })('cwr',
       '194a1c89-87d8-41a3-9d1b-5c5cd3dafbd0',
       '1.0.0',
       'us-east-2',
       'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
       {
           sessionSampleRate: 1,
           identityPoolId: "us-east-2:c90ef0ac-e3b8-4d1a-b313-7e73cfd21443",
           endpoint: "https://dataplane.rum.us-east-2.amazonaws.com",
           telemetries: ["performance", "errors", "http"],
           allowCookies: true,
           enableXRay: false
       });
   </script>
   ```

1. Se a aplicação for uma aplicação Web de várias páginas, você deverá repetir a etapa 1 para cada página HTML que deseja incluir na coleta de dados.

# Teste da configuração do monitor de aplicação do CloudWatch ao gerar eventos de usuário
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Depois que você inserir o snippet de código e que a aplicação atualizada estiver em execução, você poderá testá-la gerando eventos do usuário manualmente. Para esse teste, recomendamos que faça o seguinte. Esse teste gera cobranças padrão do CloudWatch RUM.
+ Navegar entre páginas em sua aplicação Web.
+ Criar várias sessões de usuário, usando navegadores e dispositivos diferentes.
+ Fazer solicitações.
+ Causar erros do JavaScript.

Depois de gerar alguns eventos, visualize-os no painel do CloudWatch RUM. Para obter mais informações, consulte [Visualizar o painel do CloudWatch RUM](CloudWatch-RUM-view-data.md).

Os dados das sessões do usuário podem levar até 15 minutos para serem exibidos no painel.

Se você não vir dados 15 minutos após gerar eventos na aplicação, consulte [Solucionar problemas do CloudWatch RUM](CloudWatch-RUM-troubleshooting.md).

# Usar políticas baseadas em recursos com o CloudWatch RUM
<a name="CloudWatch-RUM-resource-policies"></a>

Você pode anexar uma política de recursos a um monitor de aplicação do CloudWatch RUM. Por padrão, os monitores de aplicações não têm uma política de recursos anexada a eles. As políticas baseadas em recursos do CloudWatch RUM não são compatíveis com acesso entre contas.

Para saber mais sobre as políticas de recursos da AWS, consulte [Políticas baseadas em identidade e em recurso](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).

Para saber mais sobre como políticas de recursos e políticas de identidade são avaliadas, consulte [Lógica da avaliação de política](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html).

Para saber mais sobre a gramática de políticas do IAM, consulte [Referência de elemento de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html).

## Ações compatíveis
<a name="RUM-resource-policies-actions"></a>

Políticas baseadas em recursos em monitores de aplicações compatíveis com a ação `rum:PutRumEvents`.

## Exemplos de políticas para uso com o CloudWatch RUM
<a name="RUM-resource-policies-samples"></a>

O exemplo a seguir permite que qualquer pessoa grave dados no monitor da aplicação, incluindo aqueles sem credenciais do SigV4.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "rum:PutRumEvents",
            "Resource": "arn:aws:rum:us-east-1:123456789012:appmonitor/app monitor name",
            "Principal": "*"
        }
    ]
}
```

------

Você pode modificar a política para bloquear endereços IP de origem específicos usando a chave de condição `aws:SourceIp`. Com este exemplo, usando esta política, o PutRumEvents do endereço IP listado será rejeitado. Todas as outras solicitações de outros endereços IP serão aceitas. Para obter mais informações sobre essa chave de condição, consulte [Propriedades da rede](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-network-properties) no Guia do usuário do IAM.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "rum:PutRumEvents",
            "Resource": "arn:aws:rum:us-east-1:123456789012:appmonitor/AppMonitorName",
            "Principal": "*"
        },
        {
            "Effect": "Deny",
            "Action": "rum:PutRumEvents",
            "Resource": "arn:aws:rum:us-east-1:123456789012:appmonitor/AppMonitorName",
            "Principal": "*",
            "Condition": {
                "NotIpAddress": {
                "aws:SourceIp": "198.51.100.252"
                }
            }
        }
    ]
}
```

------

Além disso, você pode usar a chave de contexto do serviço `rum:alias` para controlar quais solicitações são aceitas. 

Em monitores de aplicações Web, é necessário configurar o cliente Web para enviar o `Alias` usando a versão 1.20 ou posterior do cliente Web do CloudWatch RUM, conforme descrito em [Application-specific Configurations](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md) no GitHub.

Em monitores de aplicações móveis, você deve configurar a instrumentação de acordo com o SDK.
+ As aplicações iOS usam o [SDK do AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-swift) para iOS. 
+ As aplicações Adroid usam o [SDK do AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android) para Android.

No exemplo a seguir, a política do recurso exige que as solicitações contenham um `alias1` ou `alias2` para o evento ser aceito.

```
    {
    "Version":"2012-10-17",                   
    "Statement": [
        {
            "Sid": "AllowRUMPutEvents",
            "Effect": "Allow",
            "Action": "rum:PutRumEvents",
            "Resource": "arn:aws:rum:us-east-1:123456789012:appmonitor/MyApplication",
            "Principal": "*",
            "Condition": {
                "StringEquals": {
                    "rum:alias":["alias1", "alias2"]
                }
            }
        }
    ]
}
```

# Configurar o cliente da Web do CloudWatch RUM
<a name="CloudWatch-RUM-configure-client"></a>

As aplicações podem usar um dos snippets de código gerados pelo CloudWatch RUM para instalar o cliente da Web do CloudWatch RUM. Os snippets gerados oferecem suporte a dois métodos de instalação: como um módulo JavaScript via NPM ou por meio de uma rede de entrega de conteúdo (CDN). Para proporcionar o melhor desempenho, recomendamos usar o método de instalação via NPM. Para obter mais informações sobre o uso desse método, consulte [Instalar como um módulo JavaScript](https://github.com/aws-observability/aws-rum-web/blob/main/docs/npm_installation.md).

Se você usar a opção de instalação por CDN, os bloqueadores de anúncios poderão bloquear a CDN padrão fornecida pelo CloudWatch RUM. Isso desabilita o monitoramento de aplicações para usuários com bloqueadores de anúncios instalados. Por isso, recomendamos usar a CDN padrão somente para integração inicial com o CloudWatch RUM. Para obter mais informações sobre as formas de mitigar esse problema, consulte [Instrumentar a aplicação](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#instrument-the-application).

O snippet de código permanece na etiqueta `<head>` de um arquivo HTML e instala o cliente da Web fazendo o download o cliente da Web e, em seguida, configurando o cliente da Web para a aplicação monitorada. O snippet é uma função autoexecutável que se parece com a seguinte. Neste exemplo, o corpo da função do snippet foi omitido para legibilidade.

```
<script>
(function(n,i,v,r,s,c,u,x,z){...})(
'cwr',
'00000000-0000-0000-0000-000000000000',
'1.0.0',
'us-west-2',
'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
{ /* Configuration Options Here */ }
);
<script>
```

## Argumentos
<a name="CloudWatch-RUM-configure-client-arguments"></a>

O snippet de código aceita seis argumentos:
+ Um namespace para executar comandos no cliente da Web, como `'cwr'`
+ O ID do monitor de aplicações, como `'00000000-0000-0000-0000-000000000000'`
+ A versão da aplicação, como `'1.0.0'`
+ A região da AWS do monitor de aplicações, como `'us-west-2'`
+ O URL do cliente da Web, como `'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js'`
+ Opções de configuração específicas da aplicação. Para obter mais informações, consulte a seção a seguir:

## Ignorar erros
<a name="CloudWatch-RUM-configure-ignore-errors"></a>

O cliente Web do CloudWatch RUM escuta todos os tipos de erros que ocorrem nas suas aplicações. Se a aplicação emitir erros de JavaScript que você não deseja visualizar no painel do CloudWatch RUM, o cliente Web do CloudWatch RUM poderá ser configurado para filtrar esses erros. Assim, você verá apenas os eventos de erro relevantes no painel do CloudWatch RUM. Por exemplo, você pode optar por não visualizar alguns erros de JavaScript no painel porque já identificou uma correção para eles e o volume desses erros está mascarando outros. Você também pode ignorar erros que não podem ser corrigidos porque pertencem a uma biblioteca de terceiros.

Para obter mais informações sobre como instrumentar o cliente Web para filtrar erros específicos de JavaScript, consulte o exemplo em [Errors](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md#errors) (Erros) na documentação do cliente Web do Github.

## Opções de configuração
<a name="CloudWatch-RUM-configure-options"></a>

Para obter informações sobre as opções de configuração disponíveis para o cliente da Web CloudWatch RUM, consulte a[Documentação do cliente da Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md)

# Habilitar a desminificação de rastreamentos de pilha de erros em JavaScript
<a name="CloudWatch-RUM-JavaScriptStackTraceSourceMaps"></a>

Quando o código-fonte JavaScript da sua aplicação Web é minificado, os rastreamentos de pilha de erros podem ser difíceis de ler. Você pode habilitar a desminificação dos rastreamentos de pilha fazendo o upload de seus mapas de origem para o Amazon S3. O CloudWatch RUM recuperará os mapas de origem para mapear os números de linha e coluna no código-fonte minificado e retorná-los ao código-fonte original não minificado. Isso melhorará a legibilidade dos rastreamentos de pilha de erros e ajudará a identificar a localização do erro no código-fonte original. 

## Requisitos e sintaxe
<a name="CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps"></a>

Os mapas de origem são cruciais para depurar e rastrear problemas em sua aplicação Web em diferentes versões. Certifique-se de que cada versão da aplicação Web tenha um mapa de origem único. Cada versão deve ter seu próprio releaseId exclusivo. Um releaseId precisa ser uma string com 1 a 200 caracteres e só pode conter letras, números, sublinhados, hifens, dois pontos, barras e pontos. Para adicionar o `releaseId` como metadados aos eventos do RUM, configure o cliente Web do CloudWatch RUM.

Espera-se que os mapas de origem sejam arquivos JSON simples, seguindo a estrutura definida pela especificação [Source Map V3](https://sourcemaps.info/spec.html). Os campos obrigatórios são: `version`, `file`, `sources`, `names` e `mappings`.

Certifique-se de que o tamanho de cada mapa de origem não exceda o limite de 50 MB. Além disso, o serviço RUM recuperará apenas até 50 MB de mapas de origem por rastreamento de pilha. Se necessário, divida o código-fonte em vários pedaços menores. Para obter mais informações, consulte [Code Splitting with WebpackJS](https://webpack.js.org/guides/code-splitting/).

**Topics**
+ [Requisitos e sintaxe](#CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps)
+ [Configurar a política de recursos do bucket do Amazon S3 para permitir acesso ao serviço RUM](#CloudWatch-RUM-ConfigureS3)
+ [Fazer upload de mapas de origem](#CloudWatch-RUM-UploadSourceMaps)
+ [Configurar releaseId no cliente Web do CloudWatch RUM](#CloudWatch-RUM-ConfigureRumID)
+ [Habilitar o monitor de aplicação do CloudWatch RUM para desminificar os rastreamentos de pilha de JavaScript](#CloudWatch-RUM-unminifyjavascript)
+ [Visualizar rastreamentos de pilha desminificados no console do RUM](#CloudWatch-RUM-viewunminifiedstacktraces)
+ [Visualizar rastreamentos de pilha desminificados no CloudWatch Logs](#CloudWatch-RUM-viewunminifiedstacktracesCWL)
+ [Solucionar problemas de mapas de origem](#CloudWatch-RUM-troubleshootsourcemaps)

## Configurar a política de recursos do bucket do Amazon S3 para permitir acesso ao serviço RUM
<a name="CloudWatch-RUM-ConfigureS3"></a>

Certifique-se de que o bucket do Amazon S3 esteja na mesma região Do seu RUM appMonitor. Configure seu bucket do Amazon S3 para permitir o acesso ao serviço RUM a fim de recuperar arquivos de mapas de origem. Inclua as chaves de contexto de condição global `aws:SourceArn` e `aws:SourceAccount` para limitar as permissões do serviço ao recurso. Essa é a maneira mais eficiente de se proteger contra o [problema "confused deputy"](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).

O exemplo a seguir mostra como é possível usar as chaves de contexto de condição global `aws:SourceArn` e `aws:SourceAccount` no Amazon S3, a fim de evitar o problema do substituto confuso.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "RUM Service S3 Read Permissions",
            "Effect": "Allow",
            "Principal": {
                "Service": "rum.amazonaws.com"
            },
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::BUCKET_NAME",
                "arn:aws:s3:::BUCKET_NAME/*"
            ],
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "ACCOUNT_ID",
                    "aws:SourceArn": "arn:aws:rum:REGION:ACCOUNT_ID:appmonitor/APP_MONITOR_NAME"
                }
            }
        }
    ]
}
```

------

Se você estiver usando chaves do AWS KMS para criptografar os dados, verifique se a política de recursos da chave está configurada de maneira semelhante para incluir as chaves de contexto de condição global `aws:SourceArn` e `aws:SourceAccount` a fim de dar acesso ao serviço RUM para usar as chaves para recuperar os arquivos do mapa de origem.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "RUM Service KMS Read Permissions",
            "Effect": "Allow",
            "Principal": {
                "Service": "rum.amazonaws.com"
            },
            "Action": "kms:Decrypt",
            "Resource": "arn:aws:kms:us-east-1:123456789012:key/KEY_ID",
            "Condition": {
                "StringEquals": {
                "aws:SourceAccount": "123456789012",
    "aws:SourceArn": "arn:aws:rum:us-east-1:123456789012/APP_MONITOR_NAME"
                }
            }
        }
    ]
}
```

------

## Fazer upload de mapas de origem
<a name="CloudWatch-RUM-UploadSourceMaps"></a>

Configure seu pacote JavaScript para gerar mapas de origem durante a minificação. Quando você compilar sua aplicação, o pacote criará um diretório (p. ex., dist) contendo os arquivos JavaScript minificados e seus mapas de origem correspondentes. Veja um exemplo a seguir.

```
./dist
    |-index.d5a07c87.js
    |-index.d5a07c87.js.map
```

Carregue os arquivos de mapa de origem em seu bucket no Amazon S3. Os arquivos devem estar localizados em uma pasta com o nome `releaseId`. Por exemplo, se o nome do meu bucket for `my-application-source-maps` e o `releaseId` for 2.0.0, o arquivo do mapa de origem estará localizado no seguinte local:

```
my-application-source-maps
    |-2.0.0
        |-index.d5a07c87.js.map
```

Para automatizar o upload de seus mapas de origem, você pode criar o seguinte script bash e executá-lo como parte do seu processo de compilação.

```
#!/bin/bash
# Ensure the script is called with required arguments
if [ "$#" -ne 2 ]; then
 echo "Usage: $0 S3_BUCKET_NAME RELEASE_ID"
 exit 1
fi

# Read arguments
S3_BUCKET="$1"
RELEASE_ID="$2"

# Set the path to your build directory
BUILD_DIR="./dist"


# Upload all .map files recursively
 if aws s3 cp "$BUILD_DIR" "s3://$S3_BUCKET/$RELEASE_ID/" --recursive --exclude "*" --include "*.map"; then
    echo "Successfully uploaded all source map files"
else
    echo "Failed to upload source map files"
fi
```

## Configurar releaseId no cliente Web do CloudWatch RUM
<a name="CloudWatch-RUM-ConfigureRumID"></a>

O CloudWatch RUM usa o `releaseId` configurado para determinar a pasta na qual deve recuperar os arquivos de mapa de origem. Nomeie o `releaseId` da mesma forma que sua pasta de arquivos de mapa de origem. Se você tiver usado o script bash fornecido acima ou um similar, o `releaseId` configurado no script deverá ser o mesmo configurado no seu cliente Web do CloudWatch RUM. É necessário usar a versão 1.21.0 ou posterior do cliente Web do CloudWatch RUM.

```
import { AwsRum, AwsRumConfig } from "aws-rum-web";

try {
    const config: AwsRumConfig = {
        sessionSampleRate: 1,
        endpoint: "https://dataplane.rum.us-west-2.amazonaws.com",
        telemetries: ["performance", "errors", "http"],
        allowCookies: true,
        releaseId: "RELEASE_ID", //Add this
    };

    const APPLICATION_ID: string = "APP_MONITOR_ID";
    const APPLICATION_VERSION: string = "1.0.0";
    const APPLICATION_REGION: string = "us-west-2";

    new AwsRum(APPLICATION_ID, APPLICATION_VERSION, APPLICATION_REGION, config);
} catch (error: any) {
    // Ignore errors thrown during CloudWatch RUM web client initialization
}
```

## Habilitar o monitor de aplicação do CloudWatch RUM para desminificar os rastreamentos de pilha de JavaScript
<a name="CloudWatch-RUM-unminifyjavascript"></a>

Para desminificar os rastreamentos de pilha de JavaScript, defina o status de SourceMap do monitor de aplicação como `ENABLED`. Informe o URI do Amazon S3 para o bucket ou pasta que contém todos os mapas de origem para seu monitor de aplicação.

Ao armazenar mapas de origem diretamente no bucket principal (não em uma subpasta), o URI do Amazon S3 deve ser formatado como `Amazon S3://BUCKET_NAME`. Nesse caso, os arquivos de mapa de origem deverão estar no seguinte local.

```
BUCKET_NAME
    |- RELEASE_ID
        |-index.d5a07c87.js.map
```

Quando um diretório secundário for a raiz, o URI do Amazon S3 deverá ser formatado como `Amazon S3://BUCKET_NAME/DIRECTORY`. Nesse caso, os arquivos de mapa de origem deverão estar no seguinte local.

```
BUCKET_NAME
    |- DIRECTORY
        |-RELEASE_ID
            |-index.d5a07c87.js.map
```

## Visualizar rastreamentos de pilha desminificados no console do RUM
<a name="CloudWatch-RUM-viewunminifiedstacktraces"></a>

Após carregar seus mapas de origem para o Amazon S3, habilitar os mapas de origem em seu monitor de aplicação do RUM e implantar sua aplicação Web com o `releaseId` configurado no cliente Web do CloudWatch RUM, selecione **Eventos** no console do RUM. Essa guia exibe os dados brutos do evento RUM. Filtre por tipo de evento de erro JS e visualize o evento de erro JS mais recente. Você verá o rastreamento de pilha desminificado no novo campo `event_details.unminifiedStack` para eventos ingeridos após a ativação do recurso.

## Visualizar rastreamentos de pilha desminificados no CloudWatch Logs
<a name="CloudWatch-RUM-viewunminifiedstacktracesCWL"></a>

Habilite o armazenamento de eventos do RUM no CloudWatch Logs ativando **Armazenamento de dados**. Após habilitá-lo, você poderá pesquisar o novo campo **event\$1details.unminifiedStack**. Isso permite que você analise tendências e relacione problemas em várias sessões usando consultas do CloudWatch Logs.

## Solucionar problemas de mapas de origem
<a name="CloudWatch-RUM-troubleshootsourcemaps"></a>

O CloudWatch RUM fornece métricas prontas para uso para solucionar problemas na configuração do mapa de origem. Essas métricas estão publicadas no namespace da métrica chamado `AWS/RUM`. Todas as métricas a seguir são publicadas com uma dimensão application\$1name. O valor dessa dimensão é o nome do monitor de aplicações. As métricas a seguir também são publicadas com uma dimensão `aws:releaseId`. O valor dessa dimensão é o `releaseId` associado ao evento de erro de JavaScript.


| MetricName | Unidade | Descrição | 
| --- | --- | --- | 
|  UnminifyLineFailureCount  |  Contagem  |  A contagem de linhas de rastreamento de pilha no evento de erro JS que falharam ao serem desminificadas. Detalhes adicionais sobre a falha serão adicionados à linha específica que falhou no campo event\$1details.unminifiedStack.  | 
|  UnminifyLineSuccessCount  |  Contagem  | A contagem de linhas de rastreamento de pilha no evento de erro JS que foram desminificadas com sucesso. | 
| UnminifyEventFailureCount | Contagem | A contagem de eventos de erro de JS que falharam em ter qualquer linha desminificada. Detalhes adicionais sobre a falha serão adicionados ao campo event\$1details.unminifiedStack. | 
| UnminifyEventSuccessCount | Contagem | A contagem de eventos de erro de JS que conseguiram ter pelo menos uma linha de rastreamento de pilha desminificada. | 

Ao desminificar uma linha no rastreamento da pilha, o CloudWatch RUM poderá falhar por vários motivos, entre eles:
+ Falha ao recuperar o arquivo de mapa de origem correspondente devido a problemas de permissão. Certifique-se de que a política de recursos do bucket esteja configurada corretamente.
+ O arquivo de mapa de origem correspondente não existe. Certifique-se de que os arquivos do mapa de origem tenham sido enviados para o bucket ou para a pasta certa com o mesmo nome do releaseId configurado em seu cliente Web do CloudWatch RUM.
+ O arquivo de mapa de origem correspondente é muito grande. Divida seu código-fonte em partes menores.
+ Já há 50 MB de arquivos de mapa de origem recuperados para o rastreamento da pilha. Reduza o tamanho do rastreamento da pilha, pois 50 MB é uma limitação no lado do serviço.
+ O mapa de origem é inválido e não pôde ser indexado. Certifique-se de que o mapa de origem seja um JSON simples, seguindo a estrutura definida pela especificação Source Map V3 e inclua os seguintes campos: version, file, sources, names, mappings.
+ O mapa de origem não conseguiu mapear o código-fonte minificado de volta para o rastreamento de pilha não minificado. Certifique-se de que o mapa de origem seja o mapa de origem correto para o releaseId fornecido.

# Regionalização
<a name="CloudWatch-RUM-Regionalization"></a>

Esta seção ilustra estratégias para usar o CloudWatch RUM com aplicações em diferentes regiões.

## Minha aplicação está implantada em várias regiões da AWS
<a name="CloudWatch-RUM-Regionalization-multiple"></a>

Se a aplicação estiver implantada em várias regiões da AWS, você terá três opções:
+ Implantar um monitor de aplicações em uma região, em uma conta, atendendo a todas as regiões.
+ Implantar monitores de aplicações separados para cada região, em contas exclusivas.
+ Implantar monitores de aplicações separados para cada região, tudo em uma conta.

A vantagem de usar um monitor de aplicações é que todos os dados serão centralizados em uma visualização e todos os logs serão gravados no mesmo grupo de logs no CloudWatch Logs. Com um único monitor de aplicações há uma pequena latência adicional para solicitações e um único ponto de falha.

O uso de vários monitores de aplicações remove o único ponto de falha, mas impede que todos os dados sejam combinados em uma visualização.

### O CloudWatch RUM não foi lançado em algumas regiões nas quais minha aplicação está implantada
<a name="CloudWatch-RUM-Regionalization-notavailable"></a>

O CloudWatch RUM é lançado em várias regiões e tem ampla cobertura geográfica. Ao configurar o CloudWatch RUM nas regiões em que ele está disponível, é possível obter os benefícios. Os usuários finais podem estar em qualquer lugar e ainda ter suas sessões incluídas se você tiver configurado um monitor de aplicações na região à qual eles estão se conectando.

Porém, o CloudWatch RUM ainda não foi lançado em nenhuma região da China. Você não pode enviar dados para o CloudWatch RUM a partir dessas regiões.

# Usar grupos de páginas
<a name="CloudWatch-RUM-page-groups"></a>

Use grupos de páginas para associar diferentes páginas na aplicação e poder ver analytics agregadas para esses grupos. Por exemplo, você pode ver o tempo de carregamento agregado de todas as suas páginas de destino. 

Para criar um grupo de páginas, adicione uma ou mais etiquetas aos eventos de visualização de página no cliente Web do CloudWatch RUM. Os exemplos a seguir colocam a página `/home` nos grupos de páginas `en` e `landing`.

**Exemplo de script incorporado**

```
cwr('recordPageView', { pageId: '/home', pageTags: ['en', 'landing']});
```

**Exemplo de módulo JavaScript**

```
awsRum.recordPageView({ pageId: '/home', pageTags: ['en', 'landing']});
```

**nota**  
Os grupos de páginas têm como objetivo facilitar a agregação de analytics em diferentes páginas. Para obter informações sobre como definir e manipular `pageIds` para sua aplicação, consulte a seção **Registro manual de visualizações de páginas** em [Modificação do trecho de código para a configuração do cliente Web do CloudWatch RUM (opcional)](CloudWatch-RUM-modify-snippet.md).

# Especificar metadados personalizados
<a name="CloudWatch-RUM-custom-metadata"></a>

O CloudWatch RUM anexa dados adicionais a cada evento como metadados. Metadados de eventos consistem em atributos sob a forma de pares chave-valor. Você pode usar esses atributos para pesquisar ou filtrar eventos no console do CloudWatch RUM. Por padrão, o CloudWatch RUM cria alguns metadados para você. Para obter mais informações sobre metadados padrão, consulte [Metadados de evento do RUM](CloudWatch-RUM-datacollected.md#CloudWatch-RUM-datacollected-metadata).

Você também pode usar o cliente da Web do CloudWatch RUM para adicionar metadados personalizados aos eventos do CloudWatch RUM. Os metadados personalizados podem incluir atributos de sessão e atributos de página.

Para adicionar metadados personalizados, você deve usar a versão 1.10.0 ou posterior do cliente da Web do CloudWatch RUM.

## Requisitos e sintaxe
<a name="CloudWatch-RUM-custom-metadata-syntax"></a>

Cada evento pode incluir até 10 atributos personalizados nos metadados. Os requisitos de sintaxe para atributos personalizados são os seguintes:
+ **Chaves**
  + Máximo de 128 caracteres
  + Podem incluir caracteres alfanuméricos, dois pontos (:) e sublinhas (\$1)
  + Não podem começar com `aws:`.
  + Não pode consistir inteiramente em nenhuma das palavras-chave reservadas listadas na seção a seguir. É permitido usar essas palavras-chave como parte de um nome de chave mais longo.
+ **Valores**
  + Máximo de 256 caracteres
  + Devem ser strings, números ou valores boolianos

**Palavras-chave reservadas**

Você não pode usar as palavras-chave reservadas a seguir como nomes de chave inteiros. Você pode usar as palavras-chave a seguir como parte de um nome de chave mais longo, como `applicationVersion`.
+ `browserLanguage`
+ `browserName`
+ `browserVersion`
+ `countryCode`
+ `deviceType`
+ `domain`
+ `interaction`
+ `osName`
+ `osVersion`
+ `pageId`
+ `pageTags`
+ `pageTitle`
+ `pageUrl`
+ `parentPageId`
+ `platformType`
+ `referrerUrl`
+ `subdivisionCode`
+ `title`
+ `url`
+ `version`

**nota**  
O CloudWatch RUM remove os atributos personalizados dos eventos do RUM se um atributo incluir uma chave ou valor que não seja válido, ou se o limite de 10 atributos personalizados por evento já tiver sido atingido. 

## Adicionar atributos de sessão
<a name="CloudWatch-RUM-session-attributes"></a>

Se você configurar atributos de sessão personalizados, eles serão adicionados a todos os eventos de uma sessão. Você configura os atributos de sessão durante a inicialização do cliente da Web do CloudWatch RUM ou no runtime usando o comando `addSessionAttributes`.

Por exemplo, você pode adicionar a versão da aplicação como um atributo de sessão. Em seguida, no console do CloudWatch RUM, você pode filtrar os erros por versão para descobrir se uma taxa de erro maior está associada a uma determinada versão da aplicação. 

**Adicionar um atributo de sessão na inicialização, exemplo de NPM**

A seção de código em negrito adiciona o atributo de sessão.

```
import { AwsRum, AwsRumConfig } from 'aws-rum-web';

try {
  const config: AwsRumConfig = {
    allowCookies: true,
    endpoint: "https://dataplane.rum.us-west-2.amazonaws.com",
    guestRoleArn: "arn:aws:iam::000000000000:role/RUM-Monitor-us-west-2-000000000000-00xx-Unauth",
    identityPoolId: "us-west-2:00000000-0000-0000-0000-000000000000",
    sessionSampleRate: 1,
    telemetries: ['errors', 'performance'],
    sessionAttributes: {
        applicationVersion: "1.3.8"
    }
  };

  const APPLICATION_ID: string = '00000000-0000-0000-0000-000000000000';
  const APPLICATION_VERSION: string = '1.0.0';
  const APPLICATION_REGION: string = 'us-west-2';

  const awsRum: AwsRum = new AwsRum(
    APPLICATION_ID,
    APPLICATION_VERSION,
    APPLICATION_REGION,
    config
  );
} catch (error) {
  // Ignore errors thrown during CloudWatch RUM web client initialization
}
```

**Adicionar um atributo de sessão no runtime, exemplo de NPM**

```
awsRum.addSessionAttributes({ 
    applicationVersion: "1.3.8"    
})
```

**Adicionar um atributo de sessão na inicialização, exemplo de script integrado**

A seção de código em negrito adiciona o atributo de sessão.

```
<script>
    (function(n,i,v,r,s,c,u,x,z){...})(
        'cwr',
        '00000000-0000-0000-0000-000000000000',
        '1.0.0',
        'us-west-2',
        'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
        {
            sessionSampleRate:1,
            guestRoleArn:'arn:aws:iam::000000000000:role/RUM-Monitor-us-west-2-000000000000-00xx-Unauth',
            identityPoolId:'us-west-2:00000000-0000-0000-0000-000000000000',
            endpoint:'https://dataplane.rum.us-west-2.amazonaws.com',
            telemetries:['errors','http','performance'],
            allowCookies:true,
            sessionAttributes: {
                applicationVersion: "1.3.8"
            }
        }
    );
</script>
```

**Adicionar um atributo de sessão no runtime, exemplo de script integrado**

```
<script>
    function addSessionAttribute() {
        cwr('addSessionAttributes', {
            applicationVersion: "1.3.8"
        })
    }
            
</script>
```

## Adicionar atributos de página
<a name="CloudWatch-RUM-page-attributes"></a>

Se você configurar atributos de página personalizados, eles serão adicionados a todos os eventos na página atual. Você configura os atributos de página durante a inicialização do cliente da Web do CloudWatch RUM ou no runtime usando o comando `recordPageView`.

Por exemplo, você pode adicionar seu modelo de página como um atributo de página. Em seguida, no console do CloudWatch RUM, você pode filtrar os erros por modelos de página para descobrir se uma taxa de erro maior está associada a um determinado modelo de página da aplicação. 

**Adicionar um atributo de página na inicialização, exemplo de NPM**

A seção de código em negrito adiciona o atributo de página.

```
const awsRum: AwsRum = new AwsRum(
    APPLICATION_ID,
    APPLICATION_VERSION,
    APPLICATION_REGION,
    { disableAutoPageView:  true // optional }
);
awsRum.recordPageView({  
    pageId:'/home',  
    pageAttributes: {
      template: 'artStudio'
    }
});
const credentialProvider = new CustomCredentialProvider();
if(awsCreds) awsRum.setAwsCredentials(credentialProvider);
```

**Adicionar um atributo de página no runtime, exemplo de NPM**

```
awsRum.recordPageView({ 
    pageId: '/home', 
    pageAttributes: {
        template: 'artStudio'
    } 
});
```

**Adicionar um atributo de página na inicialização, exemplo de script integrado**

A seção de código em negrito adiciona o atributo de página.

```
<script>
    (function(n,i,v,r,s,c,u,x,z){...})(
        'cwr',
        '00000000-0000-0000-0000-000000000000',
        '1.0.0',
        'us-west-2',
        'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
        {
            disableAutoPageView: true //optional
        }
    );
    cwr('recordPageView', { 
       pageId: '/home',  
       pageAttributes: {
           template: 'artStudio'
       }
    });
    const awsCreds = localStorage.getItem('customAwsCreds');
    if(awsCreds) cwr('setAwsCredentials', awsCreds)
</script>
```

**Adicionar um atributo de página no runtime, exemplo de script integrado**

```
<script>
    function recordPageView() {
        cwr('recordPageView', { 
            pageId: '/home', 
            pageAttributes: {
                template: 'artStudio'
            }
        });
    }        
</script>
```

## Filtrar por atributos de metadados no console
<a name="CloudWatch-RUM-custom-attiributes-console"></a>

Para filtrar as visualizações no console do CloudWatch RUM com qualquer atributo de metadados integrado ou personalizado, use a barra de pesquisa. Na barra de pesquisa, você pode especificar até 20 termos de filtro sob a forma de **chave=valor** para aplicar às visualizações. Por exemplo, para filtrar dados somente para o navegador Chrome, você pode adicionar o termo de filtro **browserName=Chrome**.

Por padrão, o console do CloudWatch RUM recupera as 100 chaves de atributos e valores mais comuns para serem exibidos no menu suspenso na barra de pesquisa. Para adicionar mais atributos de metadados como termos de filtro, insira a chave e o valor do atributo inteiros na barra de pesquisa. 

Um filtro pode incluir até 20 termos de filtro e você pode salvar até 20 filtros por monitor de aplicações. Quando você salva um filtro, ele é salvo na lista suspensa **Saved filters** (Filtros salvos). Também é possível excluir um filtro salvo. 

# Enviar eventos personalizados
<a name="CloudWatch-RUM-custom-events"></a>

O CloudWatch RUM registra e ingere os eventos listados em [Informações coletadas pelo cliente da Web CloudWatch RUM](CloudWatch-RUM-datacollected.md). Se você usar a versão 1.12.0 ou posterior do cliente da Web do CloudWatch RUM, poderá definir, registrar e enviar eventos personalizados adicionais. Você define o nome do tipo de evento e os dados a serem enviados para cada tipo de evento definido. Cada carga útil de evento personalizado pode ter até 6 KB.

Os eventos personalizados só serão ingeridos se o monitor de aplicações tiver eventos personalizados habilitados. Para atualizar as configurações do monitor de aplicações, use o console do CloudWatch RUM ou a API [UpdateAppMonitor](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_UpdateAppMonitor.html). 

Após habilitar eventos personalizados, e definir e enviar os eventos personalizados, você poderá pesquisá-los. Para isso, use a guia **Events** (Eventos) no console do CloudWatch RUM. Pesquisar usando o tipo de evento.

## Requisitos e sintaxe
<a name="CloudWatch-RUM-custom-event-syntax"></a>

Os eventos personalizados consistem em um tipo de evento e detalhes do evento. Os requisitos para cada um deles são os seguintes:
+ **Tipo de evento**
  + Isso pode ser o **tipo** ou o **nome** do evento. Por exemplo, o tipo de evento integrado do CloudWatch RUM denominado **JsError** tem um tipo de evento de `com.amazon.rum.js_error_event`.
  + Deve ter de 1 a 256 caracteres.
  + Pode ser uma combinação de caracteres alfanuméricos, sublinhas, hifens e pontos.
+ **Detalhes do evento**
  + Contém os dados reais que você deseja registrar no CloudWatch RUM.
  + Deve ser um objeto que consiste em campos e valores.

## Exemplos de registro de eventos personalizados
<a name="CloudWatch-RUM-custom-event-examples"></a>

Há duas maneiras de registrar eventos personalizados no cliente da Web do CloudWatch RUM. 
+ Usar a API `recordEvent` do cliente da Web do CloudWatch RUM.
+ Usar um plug-in personalizado.

**Enviar um evento personalizado usando a API `recordEvent`, exemplo de NPM**

```
awsRum.recordEvent('my_custom_event', {
        location: 'IAD', 
        current_url: 'amazonaws.com', 
        user_interaction: {
            interaction_1 : "click",
            interaction_2 : "scroll"
        }, 
        visit_count:10
    }
)
```

**Enviar um evento personalizado usando a API `recordEvent`, exemplo de script integrado**

```
cwr('recordEvent', {
    type: 'my_custom_event', 
    data: {
        location: 'IAD', 
        current_url: 'amazonaws.com', 
        user_interaction: {
            interaction_1 : "click",
            interaction_2 : "scroll"
        }, 
        visit_count:10
    }
})
```

**Exemplo de envio de um evento personalizado usando um plug-in personalizado**

```
// Example of a plugin that listens to a scroll event, and
// records a 'custom_scroll_event' that contains the timestamp of the event.
class MyCustomPlugin implements Plugin {
    // Initialize MyCustomPlugin.
    constructor() {
        this.enabled;
        this.context;
        this.id = 'custom_event_plugin';
    }
    // Load MyCustomPlugin.
    load(context) {
        this.context = context;
        this.enable();
    }
    // Turn on MyCustomPlugin.
    enable() {
        this.enabled = true;
        this.addEventHandler();
    }
    // Turn off MyCustomPlugin.
    disable() {
        this.enabled = false;
        this.removeEventHandler();
    }
    // Return MyCustomPlugin Id.
    getPluginId() {
        return this.id;
    }
    // Record custom event.
    record(data) {
        this.context.record('custom_scroll_event', data);
    }
    // EventHandler.
    private eventHandler = (scrollEvent: Event) => {
        this.record({timestamp: Date.now()})
    }
    // Attach an eventHandler to scroll event.
    private addEventHandler(): void {
        window.addEventListener('scroll', this.eventHandler);
    }
    // Detach eventHandler from scroll event.
    private removeEventHandler(): void {
        window.removeEventListender('scroll', this.eventHandler);
    }
}
```

# Visualizar o painel do CloudWatch RUM
<a name="CloudWatch-RUM-view-data"></a>

O CloudWatch RUM ajuda a coletar dados de sessões de usuário sobre a performance da aplicação, incluindo tempos de carregamento de página, pontuação Apdex, informações sobre o dispositivo, geolocalização das sessões de usuário e sessões com erros. Todas essas informações são exibidas em um painel.

Para visualizar o painel do RUM:

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 **Application Signals** e, em seguida, **RUM**.

O console do RUM exibe uma visão em lista de todos os monitores de aplicações. A coluna **Plataforma** indica se cada monitor de aplicações é para aplicações Web, Android ou iOS. Selecione um monitor de aplicação para acessar visualizações detalhadas com as guias **Desempenho**, **Erros**, **Sessões**, **Métricas** e **Configuração**.

## Painel de aplicação Web
<a name="CloudWatch-RUM-web-dashboard"></a>

Quando você selecionar um monitor de aplicações Web, verá as seguintes guias:
+ A guia **Performance** exibe informações de performance da página, incluindo tempos de carregamento, informações de solicitações, sinais vitais da Web e número de carregamentos ao longo do tempo. Essa visualização apresenta gráficos interativos de sinais vitais da Web, em que você pode ver os diferentes valores percentuais dos principais sinais vitais da Web para as páginas e escolher pontos de dados no gráfico para visualizar os eventos associados capturados pelo CloudWatch RUM. A partir daí, você pode analisar mais eventos relacionados ao pico de métricas ou visualizar os detalhes da página de um evento selecionado para identificar condições específicas que causam problemas de performance.

  Nessa guia, você também pode alternar a visualização entre **Carregamentos de página**, **Solicitações** e **Localização** para ver mais detalhes sobre a performance da página.
+ A guia **Erros** exibe informações de erro de Javascript, incluindo a mensagem de erro mais vista por usuários e os dispositivos e navegadores com a maioria dos erros. Esta visualização inclui um histograma dos erros e uma exibição em lista dos erros. É possível filtrar a lista de erros por detalhes de usuário e de evento. Escolha uma mensagem de erro para ver mais detalhes.
+ A guia **Solicitações de HTTP** exibe informações da solicitação de HTTP, incluindo o URL da solicitação com mais erros e os dispositivos e navegadores com mais erros. Esta guia inclui um histograma das solicitações, uma exibição de lista de solicitações e uma exibição de lista de erros de rede. É possível filtrar as listas por detalhes de usuário e de evento. Escolha um código de resposta ou uma mensagem de erro para ver mais detalhes sobre a solicitação ou o erro de rede, respectivamente.
+ A guia **Sessões** exibe as métricas da sessão. Esta guia inclui um histograma dos eventos de início da sessão e uma exibição em lista das sessões. É possível filtrar a lista de sessões por tipo de evento, detalhes de usuário e detalhes de evento. Escolha um **sessionId** para ver mais detalhes sobre uma sessão.
+ A guia **Eventos** exibe um histograma dos eventos do RUM e uma exibição em lista dos eventos. É possível filtrar a lista de eventos por tipo de evento, detalhes de usuário e detalhes de evento. Escolha um evento RUM para ver o evento bruto.
+ A guia **Browser & Devices** (Navegadores e dispositivos) exibe informações como a performance e o uso de diferentes navegadores e dispositivos para acessar sua aplicação. Esta visualização inclui controles para alternar o foco da visualização entre **Navegadores** e **Dispositivos**.

  Se você restringir o escopo a um único navegador, verá os dados detalhados pela versão do navegador.
+ A guia **User Journey** (Jornada do usuário) exibe os caminhos que seus clientes usam para navegar pela aplicação. É possível ver de onde seus clientes entram na aplicação e para qual página eles saem página eles saem da aplicação. Também é possível ver os caminhos que eles seguem e a porcentagem de clientes que seguem esses caminhos. Você pode pausar em um nó para obter mais detalhes sobre essa página. Você pode escolher um único caminho para destacar as conexões para facilitar a visualização.
+  A guia **Métricas** exibe todas as métricas padrão do CloudWatch publicadas pelo monitor de aplicações, incluindo indicadores vitais de performance na Web, métricas de erro (erros de JavaScript, erros/falhas de HTTP), volume, fluxo de usuários e métricas de apdex. Se você criou métricas ampliadas para a aplicação, a guia também inclui um subconjunto dessas métricas na seção de métricas ampliadas. Esse subconjunto inclui métricas do tipo PageViewCount, PerformanceNavigationDuration, Http4xxCount, Http5xxCount e JsErrorCount. O painel mostra três variações de métrica por tipo de métrica. Como essas são métricas do CloudWatch, é possível também exportar essa guia para seu próprio painel usando a opção **Adicionar ao painel** e atualizá-la para incluir mais métricas. 

(Opcional) Em qualquer uma das seis primeiras guias, é possível escolher o botão **Páginas** e selecionar uma página ou um grupo de páginas da lista. Isso reduz os dados exibidos para uma única página ou grupo de páginas da aplicação. Você também pode marcar páginas e grupos de páginas na lista como favoritos.

## Painel de aplicação móvel
<a name="CloudWatch-RUM-mobile-dashboard"></a>

Quando você selecionar um monitor de aplicações móveis, verá as seguintes guias:
+ A guia **Performance** fornece informações sobre a performance da aplicação móvel, incluindo tempos de carregamento de tela, tempos da inicialização da aplicação (a frio e a morno), métricas de performance e pontuações de Apdex longo do tempo. A visão detalhada detalha a performance por nomes de tela, versões do sistema operacional, versões da aplicação, dispositivos e países. Clicar em um tempo de carregamento da tela, hora de inicialização da aplicação ou ponto de dados de local no gráfico abrirá o painel de diagnóstico à direita, que fornece mais informações relevantes sobre o ponto de dados, que consistem nas mais recentes sessões correlacionadas e links para a guia **Sessões** para solução de problemas.

  Nessa guia, é possível também alternar a visão entre **Carregamentos de página**, **Inicializações da aplicação** e **Local** para ver mais detalhes sobre a performance da aplicação.

  A guia também apresenta pontuação do índice de performance da aplicação (Apdex), que indica o nível de satisfação dos usuários finais. As pontuações variam de 0 (menos satisfeitos) a 1 (mais satisfeitos). As pontuações são baseadas apenas na performance da aplicação. Para obter mais informações sobre as pontuações do Apdex, consulte [Como o CloudWatch RUM define pontuações do Apdex](#CloudWatch-RUM-apdex).
+ A guia **Erros** subdivide os problemas da aplicação em três categorias: erros de rede, panes e ANRs (Android)/congelamentos da aplicação (iOS). A guia **Erros de rede** tem um gráfico de linhas mostrando a latência da rede, os erros do cliente (código de status 4xx) e os erros do servidor (código de status 5xx). Clicar em um ponto de dados de qualquer dessas linhas no gráfico abre o painel de diagnóstico. A tabela inferior lista as 100 rotas de rede mais comuns. Clicar em um botão de seleção filtra o gráfico de linhas pela rota de rede selecionada.

  Da mesma forma, as guias **Panes** e **ANRs/congelamentos da aplicação** mostram uma série de linhas com a contagem de cada erro, e eles são difíceis de resolver. A tabela inferior exibe a mensagem de pane mais frequente ou o rastro da pilha de ANRs/congelamentos da aplicação. Clicar em um botão de seleção filtra o gráfico e clicar na mensagem de erro mostra todo o rastro da pilha.
+ A guia **Sessões** exibe uma tabela que lista todas as sessões em ordem cronológica decrescente. Na parte inferior, uma visão em cascata mostra toda a telemetria da sessão selecionada, o que ajuda a monitorar as interações do usuário e identificar problemas de performance. Qualquer linha da cascata pode ser selecionada para abrir o painel de diagnóstico. Nas solicitações HTTP, você verá um **traceId** que leva ao console Rastros.

  Nas solicitações HTTP com códigos de status que não 2xx, panes ou ANRs (Android)/congelamentos de aplicação (iOS), o painel de diagnóstico inclui uma guia **Exceção** com o rastro da pilha. O botão **Visualizar** na cascata permite acesso rápido a essas informações.
+ A guia **Métricas** exibe todas as métricas padrão do CloudWatch publicadas pelo monitor de aplicações, incluindo métricas de performance (tempos de carregamento da tela, tempos de inicialização inativa da aplicação), métricas de erro (panes, ANRS/congelamentos de aplicação, erros/falhas de HTTP), métricas de volume e apdex. Se você criou métricas ampliadas para a aplicação, a guia também inclui um subconjunto dessas métricas na seção de métricas ampliadas. Esse subconjunto inclui métricas do tipo ScreenLoadTime, ScreenLoadCount, CrashCount, Http4xxCount, Http5xxCount, ANRCount/AppHangCount, ColdLaunchTime e WarmLaunchTime. O painel mostra três variações de métrica por tipo de métrica. Como essas são métricas do CloudWatch, é possível também exportar essa guia para seu próprio painel usando a opção **Adicionar ao painel** e atualizá-la para incluir mais métricas.
+ A guia **Configuração** fornece acesso às configurações gerais e aos detalhes da configuração do monitor de aplicações. Você também pode acessar a guia **Trechos de código**, que contém instruções para instrumentar a aplicação móvel com o SDK do ADOT, incluindo opções de instrumentação manual e instrumentação de código zero.

### Como o CloudWatch RUM define pontuações do Apdex
<a name="CloudWatch-RUM-apdex"></a>

O Apdex (Application Performance Index) é um padrão aberto que define um método para relatar, comparar e classificar o tempo de resposta da aplicação. Uma pontuação do Apdex ajuda você a entender e identificar o impacto na performance da aplicação ao longo do tempo.

A pontuação de Apdex indica que as pontuações do nível de satisfação dos usuários finais. As pontuações variam de 0 (menos satisfeitos) a 1 (mais satisfeitos). As pontuações são baseadas apenas na performance da aplicação. Os usuários não são solicitados a classificar a aplicação.

Cada pontuação individual do Apdex cai em um dos três limites. Com base no limite do Apdex e no tempo real de resposta da aplicação, há três tipos de performance, da seguinte forma:
+ **Satisfatório**: o tempo real de resposta da aplicação é menor ou igual ao limite do Apdex. No CloudWatch RUM, esse limite é de 2000 ms ou menos.
+ **Tolerável**: o tempo real de resposta da aplicação é maior que o limite do Apdex, mas menor ou igual a quatro vezes o limite do Apdex. No CloudWatch RUM, esse intervalo é de 2.000 a 8.000 ms.
+ **Frustrante**: o tempo real de resposta da aplicação é maior que quatro vezes o limite do Apdex. No CloudWatch RUM, esse intervalo é superior a 8000 ms.

A pontuação total do Apdex 0-1 é calculada usando a seguinte fórmula:

`(positive scores + tolerable scores/2)/total scores * 100`

# Métricas do CloudWatch que você pode coletar com o CloudWatch RUM
<a name="CloudWatch-RUM-metrics"></a>

A tabela nesta seção lista as métricas que você coleta automaticamente com o CloudWatch RUM das aplicações Web, das aplicações móveis ou de ambas. Você também pode ver essas métricas no console do CloudWatch. Para obter mais informações, consulte [Visualizar métricas disponíveis](viewing_metrics_with_cloudwatch.md).

Você também tem a opção de enviar as métricas ampliadas para o CloudWatch. Para obter mais informações, consulte [Métricas estendidas](CloudWatch-RUM-custom-and-extended-metrics.md#CloudWatch-RUM-vended-metrics).

Essas métricas estão publicadas no namespace da métrica chamado `AWS/RUM`. Todas as métricas a seguir são publicadas com uma dimensão `application_name`. O valor dessa dimensão é o nome do monitor de aplicações. Algumas métricas também são publicadas com dimensões adicionais, conforme listado na tabela.


**Métricas de aplicações Web**  

| Métrica | Unidade | Descrição | 
| --- | --- | --- | 
|  `HttpStatusCodeCount` |  Contagem  |  A contagem de respostas HTTP na aplicação por seu código de status de resposta. Dimensões adicionais: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `Http4xxCount` |  Contagem  |  A contagem de respostas HTTP na aplicação, com o código 4xx de status da resposta. Elas são calculadas com base em eventos `http_event` do RUM que resultam em códigos 4xx.  | 
|  `Http4xxCountPerSession` |  Contagem  |  A contagem de respostas HTTP em uma sessão, com o código 4xx de status da resposta. Elas são calculadas com base em eventos `http_event` do RUM que resultam em códigos 4xx.  | 
|  `Http4xxCountPerPageView` |  Contagem  |  A contagem de respostas HTTP em uma análise de página, com o código 4xx de status da resposta. Elas são calculadas com base em eventos `http_event` do RUM que resultam em códigos 4xx.  | 
|  `Http5xxCount` |  Contagem  |  A contagem de respostas HTTP na aplicação, com o código 5xx de status da resposta. Elas são calculadas com base em eventos `http_event` do RUM que resultam em códigos 5xx.  | 
|  `Http5xxCountPerSession` |  Contagem  |  A contagem de respostas HTTP na sessão, com o código 5xx de status da resposta. Elas são calculadas com base em eventos `http_event` do RUM que resultam em códigos 5xx.  | 
|  `Http5xxCountPerPageView` |  Contagem  |  A contagem de respostas HTTP em uma análise de página, com o código 5xx de status da resposta. Elas são calculadas com base em eventos `http_event` do RUM que resultam em códigos 5xx.  | 
|  `JsErrorCount` |  Contagem  |  A contagem de eventos de erro do JavaScript ingeridos.   | 
|  `JsErrorCountPerSession` |  Contagem  |  A contagem de eventos de erro do JavaScript ingeridos em uma sessão.  | 
|  `JsErrorCountPerPageView` |  Contagem  |  A contagem de eventos de erro do JavaScript ingeridos em uma análise de página.  | 
|  `NavigationFrustratedTransaction` |  Contagem  |  A contagem de eventos de navegação com um `duration` maior que o limite frustrante, que é 8000 ms. A duração dos eventos de navegação é rastreada na métrica `PerformanceNavigationDuration`.  | 
|  `NavigationSatisfiedTransaction` |  Contagem  |  A contagem de eventos de navegação com um `duration` menor que o objetivo Apdex, que é 2000 ms. A duração dos eventos de navegação é rastreada na métrica `PerformanceNavigationDuration`.  | 
|  `NavigationToleratedTransaction` |  Contagem  |  A contagem de eventos de navegação com um `duration` entre 2000 ms e 8000 ms. A duração dos eventos de navegação é rastreada na métrica `PerformanceNavigationDuration`.  | 
|  `PageViewCount` |  Contagem  |  A contagem de eventos de visualização de página ingeridos pelo monitor de aplicações. Esse cálculo é feito contando os eventos `page_view_event` do RUM.  | 
|  `PageViewCountPerSession` |  Contagem  |  A contagem de eventos de visualização de página em uma sessão. | 
|  `PerformanceResourceDuration` |  Milissegundos  |  O `duration` de um evento de recurso. Dimensões adicionais: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `PerformanceNavigationDuration` |  Milissegundos  |  O `duration` de um evento de navegação.  | 
|  `RumEventPayloadSize` |  Bytes  |  O tamanho de cada evento ingerido pelo CloudWatch RUM. Você também pode usar a estatística `SampleCount` para essa métrica para monitorar o número de eventos que um monitor de aplicações está ingerindo.  | 
|  `SessionCount` |  Contagem  |  A contagem de eventos de início de sessão ingeridos pelo monitor de aplicações. Em outras palavras, o número de novas sessões iniciadas.  | 
|  `SessionDuration` |  Milissegundos  |  A duração de uma sessão. Essas durações são calculadas com base no tempo entre o primeiro e o último evento em uma sessão.  | 
|  `TimeOnPage` |  Milissegundos  |  A duração de uma visualização de página. Essas durações são calculadas com base no tempo até a próxima visualização de página, exceto para a última página em uma sessão, na qual é o tempo entre o primeiro e o último evento nessa página.  | 
|  `WebVitalsCumulativeLayoutShift` |  Nenhum  |  Rastreia o valor dos eventos de deslocamento de layout cumulativos.  | 
|  `WebVitalsFirstInputDelay` |  Milissegundos  |  Rastreia o valor dos primeiros eventos de atraso de entrada.  | 
|  `WebVitalsLargestContentfulPaint` |  Milissegundos  |  Acompanha o valor dos maiores eventos de contentful paint.  | 
|  `WebVitalsInteractionToNextPaint` |  Milissegundos  |  Rastreia o valor dos eventos de interação relacionados à próxima renderização visual.  | 

Você pode configurar métricas ampliadas na aplicação móvel para fornecer dimensões adicionais para análise.


**Métricas de aplicações móveis**  

| Métrica | Unidade | Descrição | 
| --- | --- | --- | 
|  `ANRCount`  |  Contagem  |  No Android apenas: o número de incidentes de ANR (aplicação irresponsiva), o que ocorre quando a aplicação não responsiva por mais de 5 segundos, resultando em pane da aplicação.  | 
|  `AppHangCount`  |  Contagem  |  No iOS apenas: o número de vezes que a aplicação ficou irresponsiva por mais de 250 ms no loop principal.  | 
|  `ColdAppLaunchFrustratedTransaction`  |  Contagem  |  O número de inicializações a frio de aplicações que levaram mais de 8 segundos para serem concluídas, provavelmente causando frustração ao usuário.  | 
|  `ColdAppLaunchSatisfiedTransaction`  |  Contagem  |  O número de inicializações a frio de aplicações que levaram menos de 2 segundos, proporcionando uma experiência satisfatória ao usuário.  | 
|  `ColdAppLaunchToleratedTransaction`  |  Contagem  |  O número de inicializações a frio de aplicações que levaram entre 2 e 8 segundos, proporcionando uma experiência de usuário tolerável, mas não ideal.  | 
|  `ColdLaunchTime`  |  Milissegundos  |  Tempo necessário para iniciar a aplicação a partir de um estado de encerrada. No Android: tempo desde `onCreate` da aplicação até a conclusão da criação da primeira atividade. No iOS: tempo do início da aplicação (determinado pelo comando `sysctl` de início do processo) até `didBecomeActiveNotification`.  | 
|  `CrashCount`  |  Contagem  |  O número de encerramentos inesperados de aplicações causados por exceções não resolvidas ou encerramento do sistema operacional. No Android: panes devido a exceções não resolvidas ou ao encerramento do sistema. No iOS: panes devido a exceções não resolvidas, erros fatais ou ao encerramento do sistema. Os dados sobre a pane são armazenados localmente e relatados na próxima inicialização da aplicação.  | 
|  `DroppedEventsCount`  |  Contagem  |  O número de eventos de log que foram descartados porque excederam o limite máximo de 30 KB por evento.  | 
|  `DroppedSpansCount`  |  Contagem  |  O número de extensões que foram descartadas porque excederam o limite máximo de 30 KB por intervalos.  | 
|  `Http4xxCount`  |  Contagem  |  Registra o número de erros do cliente HTTP encontrados pela aplicação Web ou móvel durante solicitações HTTP.  | 
|  `Http5xxCount`  |  Contagem  |  Registra o número de erros do servidor HTTP encontrados pela aplicação Web ou móvel durante solicitações HTTP.  | 
|  `LogPayloadSize`  |  Bytes  |  O tamanho em bytes dos dados de telemetria do log que estão sendo enviados ao CloudWatch RUM. Você também pode usar a estatística `SampleCount` nessa métrica para monitorar o número de eventos que um monitor de aplicações ingere.  | 
|  `NetworkLatency`  |  Milissegundos  |  O tempo necessário para as solicitações de rede serem concluídas, medindo o tempo total, do início da solicitação até a conclusão da resposta.  | 
|  `ScreenLoadCount`  |  Contagem  |  O número total de carregamentos de tela.  | 
|  `ScreenLoadToleratedTransaction`  |  Contagem  |  O número de carregamentos de tela que levaram entre 2 e 8 segundos, proporcionando uma experiência de usuário tolerável, mas não ideal.  | 
|  `SessionCount`  |  Contagem  |  O número total de sessões de usuário individuais com a aplicação. Uma sessão começa quando o usuário abre a aplicação e termina após 30 minutos de inatividade ou quando é explicitamente encerrada.  | 
|  `SpanPayloadSize`  |  Bytes  |  O tamanho em bytes dos dados de telemetria do intervalo que estão sendo enviados ao CloudWatch RUM. Você também pode usar a estatística `SampleCount` nessa métrica para monitorar o número de intervalos que um monitor de aplicações ingere.  | 
|  `WarmAppLaunchFrustratedTransaction`  |  Contagem  |  O número de inicializações mornas de aplicações que levaram mais de 8 segundos para serem concluídas, provavelmente causando frustração ao usuário.  | 
|  `WarmAppLaunchSatisfiedTransaction`  |  Contagem  |  O número de inicializações mornas de aplicações que levaram menos de 2 segundos, proporcionando uma experiência satisfatória ao usuário.  | 
|  `WarmAppLaunchToleratedTransaction`  |  Contagem  |  O número de inicializações mornas de aplicações que levaram entre 2 e 8 segundos, proporcionando uma experiência de usuário tolerável, mas não ideal.  | 
|  `WarmLaunchTime`  |  Milissegundos  |  Tempo necessário para iniciar a aplicação a partir do estado de segundo plano. No Android: tempo desde `onCreate` da aplicação até a conclusão da criação da primeira atividade. No iOS: Tempo de `UIApplicationWillEnterForegroundNotification` até `didBecomeActiveNotification`.  | 

# Métricas personalizadas e métricas ampliadas que podem ser enviadas para o CloudWatch
<a name="CloudWatch-RUM-custom-and-extended-metrics"></a>

Por padrão, os monitores de aplicações do RUM enviam métricas para o CloudWatch. Essas métricas e dimensões padrão estão listadas em [Métricas do CloudWatch que você pode coletar com o CloudWatch RUM](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html).

Além disso, é possível configurar um monitor de aplicações para exportar métricas. O monitor de aplicações pode enviar métricas estendidas, métricas personalizadas ou ambas. Ele pode enviá-las para o CloudWatch.
+ **Métricas personalizadas**: métricas personalizadas são as métricas que você define. Com métricas personalizadas, é possível usar qualquer nome e namespace de métrica. Para derivar as métricas, é possível usar quaisquer eventos personalizados, eventos incorporados, atributos personalizados ou atributos padrão.

  Saiba como enviar métricas para o CloudWatch.
+ **Métricas ampliadas**: também é possível enviar qualquer métrica padrão do CloudWatch RUM para o CloudWatch com dimensões adicionais. Dessa forma, essas métricas podem oferecer uma visão mais minuciosa.

**Topics**
+ [Métricas personalizadas](#CloudWatch-RUM-custom-metrics)
+ [Métricas estendidas](#CloudWatch-RUM-vended-metrics)

## Métricas personalizadas
<a name="CloudWatch-RUM-custom-metrics"></a>

Para enviar métricas personalizadas, você deve usar as APIs da AWS ou a AWS CLI em vez do console. Para obter informações sobre como usar as APIs da AWS, consulte [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html) e [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

O número máximo de definições de métricas estendidas e métricas personalizadas que um destino pode conter é 2000. Para cada métrica personalizada ou métrica estendida que você envia a cada destino, cada combinação de nome de dimensão e valor de dimensão conta para esse limite. Não há cobranças por métricas personalizadas derivadas de qualquer tipo de eventos ou atributos do CloudWatch RUM.

O exemplo a seguir mostra como criar uma métrica personalizada derivada de um evento personalizado. Aqui está o exemplo de evento personalizado usado:

```
cwr('recordEvent', {
    type: 'my_custom_event', 
    data: {
        location: 'IAD', 
        current_url: 'amazonaws.com', 
        user_interaction: {
            interaction_1 : "click",
            interaction_2 : "scroll"
        }, 
        visit_count:10
    }
})
```

Com este evento personalizado, é possível criar uma métrica personalizada que contabilize o número de visitas ao URL `amazonaws.com` a partir de navegadores Chrome. A definição a seguir cria uma métrica chamada `AmazonVisitsCount` em sua conta, no namespace `RUM/CustomMetrics/PageVisits`.

```
{
    "AppMonitorName":"customer-appMonitor-name",
    "Destination":"CloudWatch",
    "MetricDefinitions":[
        {
            "Name":"AmazonVisitsCount",
            "Namespace":"PageVisit",
            "ValueKey":"event_details.visit_count",
            "UnitLabel":"Count",
            "DimensionKeys":{
                "event_details.current_url": "URL"
            },
            "EventPattern":"{\"metadata\":{\"browserName\":[\"Chrome\"]},\"event_type\":[\"my_custom_event\"],\"event_details\": {\"current_url\": [\"amazonaws.com\"]}}" 
        }
    ]
}
```

## Métricas estendidas
<a name="CloudWatch-RUM-vended-metrics"></a>

Se configurar métricas ampliadas, poderá enviar qualquer métrica padrão do CloudWatch RUM para o CloudWatch com dimensões adicionais para que as métricas ofereçam uma visão mais refinada.

Para obter mais informações sobre as métricas padrão do CloudWatch RUM, consulte [Métricas do CloudWatch que você pode coletar com o CloudWatch RUM](CloudWatch-RUM-metrics.md).

O número máximo de definições de métricas estendidas e métricas personalizadas que um destino pode conter é 2000. Para cada métrica estendida ou métrica personalizada que você envia a cada destino, cada combinação de nome de dimensão e valor de dimensão conta como uma métrica estendida para esse limite.

Quando você envia métricas estendidas para o CloudWatch, pode usar o console do CloudWatch RUM para criar alarmes do CloudWatch para essas métricas.

Não há cobranças por métricas estendidas criadas para as métricas padrão do CloudWatch RUM.

### Métricas ampliadas de aplicações Web
<a name="CloudWatch-RUM-web-extended-metrics"></a>

As seguintes dimensões são compatíveis com as métricas ampliadas de aplicação Web:
+ `BrowserName`

  Exemplo de valores de dimensão: `Chrome`, `Firefox`, `Chrome Headless`
+ `CountryCode` O formato ISO-3166, com códigos de duas letras, é usado.

  Exemplo de valores de dimensão: `US`, `JP`, `DE`
+ `DeviceType`

  Exemplo de valores de dimensão: `desktop`, `mobile`, `tablet`, `embedded`
+ `FileType`

  Exemplo de valores de dimensão: `Image`, `Stylesheet` 
+ `OSName`

  Exemplo de valores de dimensão: `Linux`, `Windows`, `iOS`, `Android`
+ `PageId`

### Métricas ampliadas de aplicações móveis
<a name="CloudWatch-RUM-mobile-extended-metrics"></a>

As seguintes dimensões são compatíveis com as métricas ampliadas de aplicação móvel:
+ `ScreenName`
  + Valor do atributo de nome de tela: `attributes.screen.name` da aplicação
  + Exemplos de valores: HomeScreen, SettingsView, ProfilePage
+ `DeviceModel`
  + Valor do atributo de modelo do dispositivo: `resource.attributes.device.model.name`
  + Exemplos de valores: iPhone14,3, SM-G998B
+ `OSVersion`
  + Valor do atributo de versão do sistema operacional: `resource.attributes.os.version`
  + Exemplos de valores: 16.0, 13.0

**nota**  
Métricas padrão atualmente compatíveis com aplicações móveis: `ScreenLoadTime`, `ScreenLoadCount`, `NetworkLatency`, `Http4xxCount`, `Http5xxCount`, `CrashCount`, `ANRCount`, `AppHangCount`, `ColdLaunchTime`, `WarmLaunchTime`, `SessionCount`, `SpanPayloadSize` e `LogPayloadSize`.

### Configurar métricas estendidas usando o console
<a name="CloudWatch-RUM-extended-metrics-console"></a>

Para usar o console para enviar métricas estendidas ao CloudWatch, use as etapas a seguir.

Para saber mais sobre o uso das APIs da AWS para enviar métricas ampliadas para o CloudWatch, consulte [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html) e [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html)..

**Para usar o console para configurar um monitor de aplicações e enviar métricas estendidas do RUM para o CloudWatch**

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha o nome do monitor de aplicações que enviará as métricas.

1. Escolha a guia **Configuration** (Configuração) e escolha **RUM extended metrics** (Métricas estendidas do RUM).

1. Escolha **Send metrics** (Enviar métricas).

1. Selecione um ou mais nomes de métricas para enviar com dimensões adicionais.

1. Selecione um ou mais fatores para usar como dimensões para essas métricas. À medida que você faz suas escolhas, o número de métricas estendidas que são criadas é exibido em **Number of extended metrics** (Número de métricas estendidas).

   Esse número é calculado multiplicando o número de nomes de métricas escolhidos pelo número de dimensões diferentes que você cria.

   1. Para enviar uma métrica com o ID da página como dimensão, escolha **Browse for page ID** (Procurar ID de página) e selecione os IDs de página a serem usados.

   1. Para enviar uma métrica com o tipo de dispositivo como dimensão, escolha **Desktop devices** (Dispositivos desktop) ou **Mobile and tablets** (Celulares e tablets).

   1. Para enviar uma métrica com o sistema operacional como dimensão, selecione um ou mais sistemas operacionais em **Operating system** (Sistema operacional).

   1. Para enviar uma métrica com o tipo de navegador como dimensão, selecione um ou mais navegadores em **Browsers** (Navegadores).

   1. Para enviar uma métrica com geolocalização como dimensão, selecione um ou mais locais em **Locations** (Locais).

      Somente os locais de onde esse monitor de aplicações relatou métricas aparecerão na lista para você escolher.

1. Quando você terminar de fazer suas seleções, escolha **Send metrics** (Enviar métricas).

1. (Opcional) Na lista **Extended metrics** (Métricas estendidas), para criar um alarme que monitore uma das métricas, escolha **Create alarm** (Criar alarme) na linha dessa métrica.

   Para obter informações gerais sobre alarmes do CloudWatch, consulte [Usar alarmes do Amazon CloudWatch](CloudWatch_Alarms.md). Para ver um tutorial sobre como configurar um alarme em uma métrica estendida do CloudWatch RUM, consulte [Tutorial: criar uma métrica estendida e definir um alarme para ela](#CloudWatch-RUM-extended-metrics-alarmtutorial).

**Parar de enviar métricas estendidas**

**Para usar o console para parar de enviar métricas estendidas**

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha o nome do monitor de aplicações que enviará as métricas.

1. Escolha a guia **Configuration** (Configuração) e escolha **RUM extended metrics** (Métricas estendidas do RUM).

1. Selecione uma ou mais combinações de nome de métrica e dimensão da métrica para parar de enviar. Em seguida, escolha **Actions** (Ações), **Delete** (Excluir).

### Tutorial: criar uma métrica estendida e definir um alarme para ela
<a name="CloudWatch-RUM-extended-metrics-alarmtutorial"></a>

Este tutorial demonstra como configurar uma métrica estendida para ser enviada ao CloudWatch e, em seguida, como definir um alarme para essa métrica. Neste tutorial, você cria uma métrica que rastreia erros de JavaScript no navegador Chrome.

**Para configurar essa métrica estendida e definir um alarme para ela**

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha o nome do monitor de aplicações que enviará a métrica.

1. Escolha a guia **Configuration** (Configuração) e escolha **RUM extended metrics** (Métricas estendidas do RUM).

1. Escolha **Send metrics** (Enviar métricas).

1. Selecione **JSErrorCount**.

1. Em **Browsers** (Navegadores), selecione **Chrome**.

   Essa combinação de **JSErrorCount** e **Chrome** enviará uma métrica estendida para o CloudWatch. A métrica conta os erros de JavaScript apenas para as sessões de usuário que usam o navegador Chrome. O nome da métrica será **JSErrorCount** e o nome da dimensão será **Browser** (Navegador).

1. Escolha **Send metrics** (Enviar métricas).

1. Na lista **Extended metrics** (Métricas estendidas), escolha **Create alarm** (Criar alarme) na linha que exibe **JSErrorCount** em **Name** (Nome) e **Chrome** em **BrowserName**.

1. Em **Specify metric and conditions** (Especificar métrica e condições), confirme se os campos **Metric name** (Nome da métrica) e **BrowserName** estão preenchidos com os valores corretos.

1. Em **Statistic** (Estatística), selecione a estatística que você deseja usar para o alarme. **Average** (Média) é uma boa escolha para esse tipo de métrica de contagem.

1. Em **Period (Período)**, selecione **5 minutes (5 minutos)**.

1. Em **Condições**, faça o seguinte:
   + Escolha **Static** (Estático).
   + Escolha **Greater** (Maior) para especificar que o alarme entre no estado ALARM (ALARME) quando o número de erros for maior do que o limite que você está prestes a especificar.
   + Em **than...** (de...), insira o número para o limite do alarme. O alarme entra no estado ALARM (ALARME) quando o número de erros em um período de 5 minutos excede esse número.

1. (Opcional) Por padrão, o alarme entra no estado ALARM (ALARME) assim que o número de erros excede o número limite que você define durante um período de 5 minutos. Opcionalmente, você pode alterar esse valor para que o alarme só entre no estado ALARM (ALARME) se esse número for excedido por um período maior que 5 minutos.

   Para fazer isso, escolha **Additional configuration**(Configuração adicional) e, em **Datapoints to alarm** (Pontos de dados para alarme), especifique quantos períodos de 5 minutos precisam ter o número de erros acima do limite para disparar o alarme. Por exemplo, você pode selecionar 2 de 2 para que o alarme só seja disparado quando dois períodos consecutivos de 5 minutos ficarem acima do limite, ou 2 de 3 para que o alarme seja disparado se dois dos três períodos consecutivos de 5 minutos ficarem acima do limite. 

   Para obter mais informações sobre esse tipo de avaliação de alarme, consulte [Avaliação de alarme](alarm-evaluation.md).

1. Escolha **Próximo**.

1. Em **Configure actions** (Configurar ações), especifique o que deve acontecer quando o alarme entrar em estado de alarme. Para receber uma notificação com o Amazon SNS, faça o seguinte:
   + Escolha **Adicionar notificação**.
   + Escolha **Em alarme**.
   + Selecione um tópico existente do SNS ou crie um novo. Se você criar um novo, especifique um nome para o tópico e adicione pelo menos um endereço de e-mail a ele.

1. Escolha **Próximo**.

1. Insira um nome e uma descrição opcional para o alarme e escolha **Next** (Avançar).

1. Revise os detalhes e escolha **Create alarm** (Criar alarme).

# Proteção de dados e privacidade de dados com o CloudWatch RUM
<a name="CloudWatch-RUM-privacy"></a>

Saiba como o [modelo de responsabilidade compartilhada da AWS](https://aws.amazon.com/compliance/shared-responsibility-model/) se aplica à proteção e à privacidade de dados no Amazon CloudWatch RUM. Conforme descrito nesse modelo, a AWS é responsável por proteger a infraestrutura global que executa toda a Nuvem da AWS. Você é responsável por manter o controle sobre o conteúdo que hospeda nessa infraestrutura. Para obter mais informações sobre a privacidade de dados, consulte as [ Perguntas frequentes sobre privacidade de dados](https://aws.amazon.com/compliance/data-privacy-faq/). Para obter mais informações sobre a proteção de dados na Europa, consulte a postagem [ The AWS Shared Responsibility Model and GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) no blog de segurança da AWS. Para obter mais recursos sobre o cumprimento dos requisitos do GDPR, consulte o [ Centro Geral de Regulamentação de Proteção de Dados (GDPR)](https://aws.amazon.com/compliance/gdpr-center/).

O Amazon CloudWatch RUM gera um snippet de código para ser incorporado em seu site ou código de aplicação Web, com base na entrada dos dados do usuário final que você deseja coletar. O cliente da Web, baixado e configurado pelo snippet de código, usa cookies (ou tecnologias semelhantes) para ajudar a coletar dados do usuário final. O uso de cookies (ou tecnologias semelhantes) está sujeito a regulamentos de privacidade de dados em determinadas jurisdições. Antes de usar o Amazon CloudWatch RUM, recomendamos enfaticamente que você avalie suas obrigações de conformidade de acordo com a lei aplicável, incluindo quaisquer requisitos legais aplicáveis para fornecer avisos de privacidade legalmente adequados e obter quaisquer consentimentos necessários para o uso de cookies e o processamento (incluindo coleta) de dados do usuário final. Para obter mais informações sobre como o cliente da Web usa cookies (ou tecnologias semelhantes) e quais dados do usuário final o cliente da Web coleta, consulte [Informações coletadas pelo cliente da Web CloudWatch RUM](CloudWatch-RUM-datacollected.md) e [Cookies do cliente da Web do CloudWatch RUM (ou tecnologias semelhantes)](#CloudWatch-RUM-cookies).

É altamente recomendável que você nunca coloque informações de identificação confidenciais de clientes finais, como números de conta, endereços de e-mail ou outras informações pessoais de clientes finais, em campos de formato livre. Todos os dados inseridos no Amazon CloudWatch RUM ou em outros serviços podem ser incluídos em logs de diagnóstico. 



## Cookies do cliente da Web do CloudWatch RUM (ou tecnologias semelhantes)
<a name="CloudWatch-RUM-cookies"></a>

O cliente da Web do CloudWatch RUM coleta determinados dados sobre sessões do usuário por padrão. Você pode optar por habilitar os cookies para que o cliente da Web colete um ID de usuário e um ID de sessão que persistam nos carregamento da página. O ID do usuário é gerado aleatoriamente pelo RUM.

Se esses cookies estiverem habilitados, o RUM poderá exibir os seguintes tipos de dados quando você visualizar o painel do RUM desse monitor de aplicações.
+ Dados agregados com base em IDs de usuário, como número de usuários exclusivos e o número de usuários diferentes que receberam um erro. 
+ Dados agregados com base em IDs de sessão, como o número de sessões e o número de sessões que sofreram um erro. 
+ A *jornada do usuário*, que é a sequência de páginas que cada sessão de usuário amostrada inclui. 

**Importante**  
Se você não habilitar esses cookies (ou tecnologias semelhantes), o cliente da Web ainda registra determinadas informações sobre sessões do usuário final, como tipo ou versão do navegador, tipo ou versão do sistema operacional, tipo do dispositivo, e assim por diante. Eles são coletados para fornecer agregados insights específicos de página, como sinais vitais da Web, visualizações de página e páginas que sofreram erros. Para obter mais informações sobre os dados registrados, consulte [Informações coletadas pelo cliente da Web CloudWatch RUM](CloudWatch-RUM-datacollected.md).

# Informações coletadas pelo cliente da Web CloudWatch RUM
<a name="CloudWatch-RUM-datacollected"></a>

Esta seção documenta o esquema **PutRumEvents**, que define a estrutura dos dados que você pode coletar de sessões do usuário usando o CloudWatch RUM.

Uma solicitação **PutrumEvents** envia uma estrutura de dados com os campos a seguir para o CloudWatch RUM.
+ O ID deste lote de eventos do RUM
+ Detalhes do monitor de aplicações, que incluem o seguinte:
  + ID do monitor de aplicações
  + Versão da aplicação monitorado
+ Detalhes do usuário, que incluem o seguinte.** Isso é coletado somente se o monitor de aplicações tiver cookies habilitados.**
  + Um ID de usuário gerado pelo cliente da Web
  + ID de sessão
+ A matriz de [RUM events](#CloudWatch-RUM-datacollected-event)neste lote.

## Esquema de evento do RUM
<a name="CloudWatch-RUM-datacollected-event"></a>

A estrutura de cada evento do RUM inclui os campos a seguir.
+ O ID do evento
+ Um timestamp
+ O tipo de evento
+ O atendente do usuário
+ [Metadados](#CloudWatch-RUM-datacollected-metadata)
+ [Detalhes do evento do RUM](#CloudWatch-RUM-datacollected-eventDetails)

## Metadados de evento do RUM
<a name="CloudWatch-RUM-datacollected-metadata"></a>

Os metadados incluem metadados de página, metadados do atendente do usuário, metadados de geolocalização e metadados de domínio.

### Metadados da página
<a name="CloudWatch-RUM-datacollected-metadata-page"></a>

Os metadados da página incluem o seguinte:
+ ID da página
+ Título da página
+ ID da página pai. – **Isso será coletado somente se o monitor de aplicações tiver cookies habilitados.**
+ Profundidade da interação: **Isso será coletado somente se o monitor de aplicações tiver cookies habilitados.**
+ Tags de página: é possível adicionar tags aos eventos de página para agrupar as páginas. Para obter mais informações, consulte [Usar grupos de páginas](CloudWatch-RUM-page-groups.md).

### Metadados do atendente do usuário
<a name="CloudWatch-RUM-datacollected-metadata-useragent"></a>

Os metadados do atendente do usuário incluem o seguinte:
+ Idioma do navegador
+ Nome do navegador
+ Versão do navegador
+ Nome do sistema operacional
+ Versão do sistema operacional 
+ Tipo de dispositivo
+ Tipos de plataforma

### Metadados de localização geográfica
<a name="CloudWatch-RUM-datacollected-metadata-geolocation"></a>

Os metadados de geolocalização incluem o seguinte:
+ Código do país
+ Código de subdivisão

### Metadados do domínio
<a name="CloudWatch-RUM-datacollected-metadata-domain"></a>

Os metadados do domínio incluem o domínio da URL.

## Detalhes do evento do RUM
<a name="CloudWatch-RUM-datacollected-eventDetails"></a>

Os detalhes de um evento seguem um dos tipos de esquemas a seguir, dependendo do tipo de evento.

### Evento de início da sessão
<a name="CloudWatch-RUM-datacollected-sessionstart"></a>

Esse evento não contém campos. **Isso é coletado somente se o monitor de aplicações tiver cookies habilitados.**

### Esquema de visualização de página
<a name="CloudWatch-RUM-datacollected-pageview"></a>

Um evento de **Page View** (Exibição de página) contém as seguintes propriedades. Você pode desativar a coleção de exibição de página configurando o cliente da Web. Para obter mais informações, consulte a [ Documentação do cliente da Web do CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nome | Tipo | Descrição | 
| --- | --- | --- | 
|  **ID da página** |  String  |  Um ID que representa exclusivamente esta página dentro da aplicação. Por padrão, esse é o caminho do URL.  | 
|  **ID da página pai** |  String  |  O ID da página em que o usuário estava quando navegou para a página atual. **Isso é coletado somente se o monitor de aplicações tiver cookies habilitados.**   | 
|  **Profundidade de interação** |  String  |  **Isso é coletado somente se o monitor de aplicações tiver cookies habilitados.**   | 

### Esquema de erro do JavaScript
<a name="CloudWatch-RUM-datacollected-JavaScriptError"></a>

Os eventos de erro JavaScript gerados pelo atendente contêm as propriedades a seguir. O cliente da Web coleta esses eventos somente se você selecionou a coleta de telemetria de erros.


| Nome | Tipo | Descrição | 
| --- | --- | --- | 
|  **Tipo de erro** |  String  |  O nome do erro, se existir algum erro. Para obter mais informações, consulte [Error.prototype.Name](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name). Alguns navegadores podem não ser compatíveis com tipos de erro.  | 
|  **Mensagem de erro** |  String  |  A mensagem do erro. Para obter mais informações, consulte [Error.prototype.message](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message). Se o campo de erro não existir, esta é a mensagem do evento de erro. Para obter mais informações, consulte [ErrorEvent](https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent).  As mensagens de erro podem não ser consistentes em navegadores diferentes.  | 
|  **Rastreamento** |  String  |  O rastreamento de pilha do erro, se houver, reduzido a 150 caracteres. Para obter mais informações, consulte [Error.prototype.Stack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack).  Alguns navegadores podem não suportar rastreamentos de pilha.  | 

### Esquema de eventos DOM
<a name="CloudWatch-RUM-datacollected-DOMEvent"></a>

Os eventos do modelo de objeto de documento (DOM) gerados pelo atendente contêm as propriedades a seguir. Esses eventos não são coletados por padrão. Eles serão coletados apenas se você ativar a telemetria das interações. Para obter mais informações, consulte a [ Documentação do cliente da Web do CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nome | Tipo | Descrição | 
| --- | --- | --- | 
|  **Event** |  String  |  O tipo de evento DOM, como clicar, rolar ou passar o mouse. Para obter mais informações, consulte [Event reference](https://developer.mozilla.org/en-US/docs/Web/Events).  | 
|  **Elemento** |  String  |  O tipo de elemento DOM  | 
|  **Element ID (ID de elemento** |  String  |  Se o elemento que gerou o evento tiver uma ID, essa propriedade armazenará essa ID. Para obter mais informações, consulte[Element.id](https://developer.mozilla.org/en-US/docs/Web/API/Element/id).  | 
|  **CSSLocator** |  String  |  O localizador CSS usado para identificar o elemento DOM.  | 
|  **InteractionId** |  String  |  Um ID exclusivo para a interação entre o usuário e a interface do usuário.  | 

### Esquema de eventos de navegação
<a name="CloudWatch-RUM-datacollected-NavigationEvent"></a>

Os eventos de navegação só serão coletados se o monitor de aplicações tiver telemetria de performance ativada.

Os eventos de navegação usam as APIs [Navigation timing Level 1](https://www.w3.org/TR/navigation-timing/#performancetiming) e [Navigation timing Level 2](https://w3c.github.io/navigation-timing). As APIs de nível 2 não são compatíveis com todos os navegadores, portanto, esses campos mais novos são opcionais.

**nota**  
As Métricas de timestamp são baseadas em [DomHighrestimestamp](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp). Com APIs de Nível 2, todos os horários são, por padrão, relativos ao `startTime`. No entanto, para as de Nível 1, a métrica `navigationStart` é subtraída das métricas de timestamp para obter valores relativos. Todos os valores de timestamp estão em milissegundos.

Os eventos de navegação contêm as propriedades a seguir.


| Nome | Tipo | Descrição | Observações | 
| --- | --- | --- | --- | 
|  **initiatorType** |  String  |  Representa o tipo de recurso que iniciou o evento de performance.  |  **Value:** "navigation" **Level 1** (Nível 1): "navigation" **Level 2** (Nível 2): entryData.initiatorType | 
|  **navigationType** |  String  |  Representa o tipo de navegação. Esse atributo não é obrigatório. |  **Value:** Esse valor deve ser um dos seguintes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html) | 
|  **startTime** |  Número  |  Indica quando o evento é acionado.  |  **Value:** 0 **Level 1** (Nível 1): entryData.navigationStart - entryData.navigationStart  **Level 2** (Nível 2): entryData.startTime | 
|  **unloadEventStart** |  Número  |  Indica o momento em que o documento anterior na janela começou a descarregar após o lançamento do evento`unload`.  |  **Value:** (Valor). Se não houver documento anterior ou se o documento anterior ou um dos redirecionamentos necessários não for da mesma origem, o valor retornado será 0. **Level 1 (Nível 1:** <pre>entryData.unloadEventStart > 0<br />  ? entryData.unloadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Level 2** (Nível 2): entryData.unloadEventStart | 
|  **PromptForUnload** |  Número  |  O tempo necessário para descarregar o documento. Em outras palavras, o tempo entre `unloadEventStart` e `unloadEventEnd`. `UnloadEventEnd` representa o momento em milissegundos quando o manipulador de eventos de descarga termina.  |  **Value:** (Valor). Se não houver documento anterior ou se o documento anterior ou um dos redirecionamentos necessários não for da mesma origem, o valor retornado será 0. **Level 1** (Nível 1): entryData.unloadEventEnd - entryData.unloadEventStart **Level 2** (Nível 2): entryData.unloadEventEnd - entryData.unloadEventStart | 
|  **redirectCount** |  Número  |  Um número que representa o número de redirecionamentos desde a última navegação sem redirecionamento no contexto de navegação atual.  Esse atributo não é obrigatório. |  **Value:** (Valor) Se não houver redirecionamento ou se houver algum redirecionamento que não seja da mesma origem que o documento de destino, o valor retornado será 0. **Level 1** (Nível 1): não disponível **Level 2** (Nível 2): entryData.redirectCount | 
|  **redirectStart** |  Número  |  O momento em que o primeiro redirecionamento HTTP é iniciado.   |  **Value:** (Valor) Se não houver redirecionamento ou se houver algum redirecionamento que não seja da mesma origem que o documento de destino, o valor retornado será 0. **Level 1 (Nível 1:** <pre>entryData.redirectStart > 0<br />  ? entryData.redirectStart - entryData.navigationStart<br />  : 0</pre> **Level 2** (Nível 2): entryData.redirectStart | 
|  **redirectTime** |  Número  |  O tempo necessário para o redirecionamento HTTP. Essa é a diferença entre `redirectStart` e `redirectEnd`.   |  **Level 1** (Nível 1): entryData.redirectEnd - entryData.redirectStart **Level 2** (Nível 2): entryData.redirectEnd - entryData.redirectStart | 
|  **workerStart** |  Número  |  Esta é uma propriedade da interface `PerformanceResourceTiming`. Ela marca o início da operação do encadeamento do trabalhador. Esse atributo não é obrigatório. |  **Value:** (Valor) Se um thread do Service Worker já estiver em execução ou imediatamente antes de seu início, essa propriedade retornará a hora imediatamente antes do envio `FetchEvent`. Ela retornará 0 se o recurso não for interceptado por um Service Worker. **Level 1** (Nível 1): não disponível **Level 2** (Nível 2): entryData.workerStart | 
|  **workerTime** |  Número  |  Se o recurso for interceptado por um Service Worker, isso retornará o tempo necessário para a operação de thread do trabalhador. Esse atributo não é obrigatório. |  **Level 1** (Nível 1): não disponível  **Level 2 (Nível 2:** <pre>entryData.workerStart > 0<br />   ? entryData.fetchStart - entryData.workerStart<br />   : 0</pre>  | 
|  **fetchStart** |  Número  |  O horário em que o navegador está pronto para buscar o documento usando uma solicitação HTTP. Isso ocorre antes de verificar qualquer cache de aplicação. |  **Level 1 (Nível 1:**  <pre>: entryData.fetchStart > 0<br />  ? entryData.fetchStart - entryData.navigationStart<br />  : 0</pre> **Level 2** (Nível 2): entryData.fetchStart | 
|  **domainLookupStart** |  Número  |  O momento em que a pesquisa do domínio é iniciada. |  **Value:** (Valor) Se uma conexão persistente for usada ou se as informações forem armazenadas em um cache ou recurso local, o valor será o mesmo que `fetchStart`. **Level 1 (Nível 1:** <pre>entryData.domainLookupStart > 0<br />  ? entryData.domainLookupStart - entryData.navigationStart<br />  : 0</pre> **Level 2** (Nível 2): entryData.domainLookupStart | 
|  **DNS** |  Número  |  O tempo necessário para a pesquisa de domínio. |  **Value:** (Valor) Se os recursos e os registros DNS forem armazenados em cache, o valor esperado será 0. **Level 1** (Nível 1): entryData.domainLookupEnd - entryData.domainLookupStart **Level 2** (Nível 2): entryData.domainLookupEnd - entryData.domainLookupStart | 
|  **nextHopProtocol** |  String  |  Uma string que representa o protocolo de rede usado para buscar o recurso. Esse atributo não é obrigatório. |  **Level 1** (Nível 1): não disponível **Level 2** (Nível 2): entryData.nextHopProtocol | 
|  **connectStart** |  Número  |  O momento imediatamente anterior ao atendente do usuário começar a estabelecer a conexão com o servidor para recuperar o documento. |  **Value** (Valor): se uma conexão persistente RFC2616 for usada ou se o documento atual for recuperado de caches de aplicações relevantes ou recursos locais, esse atributo retornará o valor de `domainLookupEnd`. **Level 1 (Nível 1:** <pre>entryData.connectStart > 0<br />  ? entryData.connectStart - entryData.navigationStart<br />  : 0</pre> **Level 2** (Nível 2): entryData.connectStart  | 
|  **connect** |  Número  |  Mede o tempo necessário para estabelecer as conexões de transporte ou para executar a autenticação SSL. Também inclui o tempo bloqueado que é levado quando há muitas solicitações simultâneas emitidas pelo navegador.  |  **Level 1** (Nível 1): entryData.connectEnd - entryData.connectStart **Level 2** (Nível 2): entryData.connectEnd - entryData.connectStart | 
|  **SecureConnectionStart** |  Número  |  Se o esquema de URL da página atual for “https”, esse atributo retornará o momento imediatamente anterior ao atendente do usuário iniciar o processo de handshake para proteger a conexão atual. Ele retorna 0 se HTTPS não for usado. Para obter mais informações sobre esquemas de URL, consulte[Representação de URL](https://url.spec.whatwg.org/#concept-url-scheme).  |  **Formula:** entryData.secureConnectionStart | 
|  **tlsTime** |  Número  |  O tempo necessário para completar um Handshake do SSL.  |  **Level 1 (Nível 1:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre> **Level 2 (Nível 2:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre>  | 
|  **requestStart** |  Número  |  O momento imediatamente anterior ao atendente do usuário começar a solicitar o recurso do servidor ou de caches de aplicações relevantes ou de recursos locais.   | **Level 1 (Nível 1:** <pre>: entryData.requestStart > 0<br />  ? entryData.requestStart - entryData.navigationStart<br />  : 0<br /></pre> **Level 2** (Nível 2): entryData.requestStart | 
|  **TimeToFirstByte** |  Número  |  O tempo necessário para receber o primeiro byte de informações após a solicitação ser feita. Esse tempo é relativo ao `startTime`.   | **Level 1** (Nível 1): entryData.responseStart - entryData.requestStart **Level 2** (Nível 2): entryData.responseStart - EntryData.requestStart | 
|  **ResponseStart** |  Número  |  O tempo imediatamente posterior ao atendente analisador de HTTP do usuário receber o primeiro byte da resposta dos caches de aplicações relevantes, de recursos locais ou do servidor.   | **Level 1 (Nível 1:** <pre>entryData.responseStart > 0<br />   ? entryData.responseStart - entryData.navigationStart<br />   : 0</pre> **Level 2:** entryData.responseStart   | 
|  **ResponseTime** |  String  |  O tempo necessário para receber uma resposta completa na forma de bytes dos caches de aplicações relevantes, de recursos locais ou do servidor.   | **Level 1 (Nível 1:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre> **Level 2 (Nível 2:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre>  | 
|  **domInteractive** |  Número  |  O momento em que o analisador terminou seu trabalho no documento principal e o HTML DOM é construído. Neste momento, seu `Document.readyState` se altera para "interativo" e o evento correspondente `readystatechange` lançado.  | **Level 1 (Nível 1:** <pre>entryData.domInteractive > 0<br />  ? entryData.domInteractive - entryData.navigationStart<br />  : 0</pre> **Level 2** (Nível 2): entryData.domInteractive  | 
|  **domContentLoadedEventStart** |  Número  |  Representa o valor de tempo igual ao tempo imediatamente anterior ao atendente do usuário acionar o evento DOMContentLoaded no documento atual. O evento DOMContentLoaded é acionado quando o documento HTML inicial estiver completamente carregado e analisado. Neste momento, o documento HTML principal terminou a análise, o navegador começa a construir a árvore de renderização e os sub-recursos ainda precisam ser carregados. Ele não espera que folhas de estilo, imagens e subquadros terminem o carregamento.  | **Level 1 (Nível 1:** <pre>entryData.domContentLoadedEventStart > 0<br />  ? entryData.domContentLoadedEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Level 2** (Nível 2): entryData.domContentLoadedEventStart  | 
|  **domContentLoaded** |  Número  |  Esse horário de início e término da construção da árvore de renderização é marcado pelos `domContentLoadedEventStart` e `domContentLoadedEventEnd`. Ele permite que o CloudWatch RUM rastreie a execução. Essa propriedade é a diferença entre `domContentLoadedStart` e `domContentLoadedEnd`. Durante esse período, o DOM e o CSSOM estão prontos. Essa propriedade aguarda a execução do script, exceto scripts assíncronos e criados dinamicamente. Se os scripts dependem de folhas de estilo, o `domContentLoaded` aguarda nas folhas de estilo, também. Ele não aguarda nas imagens.   Os valores reais de `domContentLoadedStart` e `domContentLoadedEnd` se aproximam de `domContentLoaded` no painel Rede do Google Chrome. Ele indica o tempo de construção da árvore de renderização HTML DOM \$1 CSSOM desde o início do processo de carregamento da página. No caso das métricas de navegação, o valor de `domContentLoaded` representa a diferença entre os valores inicial e final, que é o tempo necessário somente para baixar sub-recursos e construção de árvore de renderização.    | **Level 2** (Nível 2): entryData.domContentLoadedEventEnd - entryData.domContentLoadedEventStart  **Level 2** (Nível 2): entryData.domContentLoadedEventEnd - entryData.domContentLoadedEventStart  | 
|  **domComplete** |  Número  |  O momento imediatamente anterior ao navegador definir a prontidão do documento atual para a sua conclusão. Nesse ponto, o carregamento de sub-recursos, como imagens, está completo. Isso inclui o tempo necessário para baixar conteúdo de bloqueio, como CSS e JavaScript síncrono. Isso se aproxima de `loadTime` no painel Rede do Google Chrome.   | **Level 1 (Nível 1:** <pre>entryData.domComplete > 0<br />  ? entryData.domComplete - entryData.navigationStart<br />  : 0<br /></pre> **Level 2** (Nível 2): entryData.domComplete  | 
|  **domProcessingTime** |  Número  |  O tempo total entre a resposta e o início do evento de carga.  | **Level 1** (Nível 1): entryData.loadEventStart - entryData.responseEnd **Level 2** (Nível 2): entryData.loadEventStart - entryData.responseEnd  | 
|  **loadEventStart** |  Número  |  O tempo imediatamente anterior ao disparo do evento `load` do documento atual.  |  **Level 1 (Nível 1:** <pre>entryData.loadEventStart > 0<br />  ? entryData.loadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Level 2** (Nível 2): entryData.loadEventStart | 
|  **loadEventTime** |  Número  |  A diferença entre `loadEventStart` e `loadEventEnd`. Funções adicionais ou lógicas aguardando esse evento de carregamento serão disparadas durante esse período. |  **Level 1** (Nível 1): entryData.loadEventEnd - entryData.loadEventStart **Level 2** (Nível 2): entryData.loadEventEnd - entryData.loadEventStart | 
|  **duration** |  String  |  A duração é o tempo total de carregamento da página. Ela registra o tempo para baixar a página principal e todos os seus sub-recursos síncronos, e também para renderizar a página. Recursos assíncronos, como scripts, continuam sendo baixados posteriormente. Essa é a diferença entre as propriedades `loadEventEnd` e `startTime` propriedades.  | **Level 1** (Nível 1): entryData.loadEventEnd - entryData.navigationStart **Level 2** (Nível 2): entryData.duration | 
|  **headerSize** |  Número  |  Devolve a diferença entre `transferSize` e `encodedBodySize`. Esse atributo não é obrigatório.  | **Level 1** (Nível 1): não disponível **Level 2** (Nível 2): entryData.transferSize - entryData.encodedBodySize **Level 2** (Nível 2): entryData.transferSize - entryData.encodedBodySize | 
|  **compressionRatio** |  Número  |  A proporção de `encodedBodySize` e `decodedBodySize`. O valor de`encodedBodySize` é o tamanho compactado do recurso, excluindo os cabeçalhos HTTP. O valor de `decodedBodySize` é o tamanho descompactado do recurso, excluindo os cabeçalhos HTTP. Esse atributo não é obrigatório.  | **Level 1** (Nível 1): não disponível **Level 2 (Nível 2:**<pre>entryData.encodedBodySize > 0<br />  ? entryData.decodedBodySize / entryData.encodedBodySize<br />  : 0</pre>  | 
|  **navigationTimingLevel** |  Número  |  A versão da API de tempo de navegação.  | **Value:** (Valor) 1 ou 2  | 

### Esquema de eventos de recurso
<a name="CloudWatch-RUM-datacollected-ResourceEvent"></a>

Os eventos de recurso são coletados somente se o monitor de aplicações tiver a telemetria de performance ativada.

Métricas de timestamp são baseadas em [The DOMHighResTimeStamp typedef](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp). Com APIs de Nível 2, por padrão, todos os horários são relativos ao `startTime`. Mas para APIs de Nível 1, a métrica `navigationStart` é subtraída das métricas de timestamp para obter valores relativos. Todos os valores de timestamp estão em milissegundos.

Os eventos de recursos gerados pelo atendente contêm as propriedades a seguir.


| Nome | Tipo | Descrição | Observações | 
| --- | --- | --- | --- | 
|  **TargetUrl** |  String  |  Retorna a URL do recurso.  |  **Fórmula:** [entryData.name](http://entrydata.name/) | 
|  **InitiatorType** |  String  |  Representa o tipo de recurso que iniciou o evento de recurso de performance.  |  **Value:** "resource" **Fórmula:** entryData.InitiatorType | 
|  **duration** |  String  |  Retorna a diferença entre as propriedades `responseEnd` e `startTime`.Esse atributo não é obrigatório.  | **Formula:** entryData.duration | 
|  **transferSize** |  Número  |  Retorna o tamanho (em octetos) do recurso buscado, incluindo os campos do cabeçalho de resposta e o corpo da carga útil da resposta.Esse atributo não é obrigatório.  | **Formula:** entryData.transferSize | 
|  **fileType** |  String  |  Extensões derivadas do padrão de URL de destino.  |   | 

### Esquema de evento largest contentful paint (maior exibição de conteúdos)
<a name="CloudWatch-RUM-datacollected-LargestPaintEvent"></a>

Os eventos de largest contentful paint event contêm as propriedades a seguir.

Esses eventos só são coletados se a telemetria de performance do monitor de aplicações estiver ativada.


| Name (Nome) | Descrição | 
| --- | --- | 
|  **Valor** |  Para obter mais informações, consulte [Web Vitals](https://web.dev/vitals/).  | 

### Evento de first input delay (atraso da primeira entrada)
<a name="CloudWatch-RUM-datacollected-FirstInputDelayEvent"></a>

Os primeiros eventos first input delay contêm as seguintes propriedades.

Esses eventos só são coletados se a telemetria de performance do monitor de aplicações estiver ativada.


| Name (Nome) | Descrição | 
| --- | --- | 
|  **Valor** |  Para obter mais informações, consulte [Web Vitals](https://web.dev/vitals/).  | 

### Evento de cumulative layout shift (deslocamento cumulativo de layout)
<a name="CloudWatch-RUM-datacollected-CumulativeShift"></a>

Os eventos de cumulative layout shift contêm as propriedades a seguir.

Esses eventos só são coletados se a telemetria de performance do monitor de aplicações estiver ativada.


| Name (Nome) | Descrição | 
| --- | --- | 
|  **Valor** |  Para obter mais informações, consulte [Web Vitals](https://web.dev/vitals/).  | 

### Evento HTTP
<a name="CloudWatch-RUM-datacollected-HTTP"></a>

Os eventos HTTP podem conter as propriedades a seguir. Ele conterá um campo `Response` ou um campo `Error`, mas não ambos.

Esses eventos só são coletados se a telemetria HTTP do monitor de aplicações estiver ativada.


| Name (Nome) | Descrição | 
| --- | --- | 
|  **Solicitação** |  O campo de solicitação inclui o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Resposta** |  O campo de resposta inclui o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Erro** |  O campo de erros inclui o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 

### Esquema de eventos de rastreamento do X-Ray
<a name="CloudWatch-RUM-datacollected-xraytraceEvent"></a>

Esses eventos são coletados somente se o monitor de aplicações tiver o rastreamento de X-Ray ativado.

Para obter informações sobre esquemas de eventos de rastreamento de X-Ray, consulte [Documentos de segmento do AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-api-segmentdocuments.html).

# Tempo de mudança de rota para aplicações de página única
<a name="CloudWatch-RUM-route-change-timing"></a>

Em uma aplicação tradicional de várias páginas, ao solicitar o carregamento de um novo conteúdo, o usuário está, na verdade, solicitando uma nova página HTML do servidor. Por isso, o cliente Web do CloudWatch RUM registra os tempos de carregamento usando as métricas regulares da API de performance.

No entanto, aplicações Web de página única usam JavaScript e Ajax para atualizar a interface sem carregar uma nova página do servidor. As atualizações de página única não são registradas pela API de tempo do navegador e, em vez disso, usam o tempo de mudança de rota.

O CloudWatch RUM é compatível tanto com o monitoramento de carregamentos de páginas inteiras do servidor como de atualizações de página única, com as seguintes diferenças:
+ No tempo de mudança de rota, não há métricas fornecidas pelo navegador, como `tlsTime`, `timeToFirstByte` e outras.
+ No tempo de mudança de rota, o campo `initiatorType` será `route_change`. 

O cliente Web do CloudWatch RUM escuta as interações do usuário que podem levar a uma mudança de rota e, quando essa interação do usuário é registrada, o cliente Web registra um carimbo de data/hora. Em seguida, o tempo de mudança de rota começará a ser contado se estas duas condições forem verdadeiras:
+ Uma API de histórico do navegador (exceto os botões avançar e voltar do navegador) foi usada para realizar a mudança de rota.
+ A diferença entre o tempo de detecção da mudança de rota e o carimbo de data/hora da interação mais recente do usuário é inferior a 1.000 ms. Isso evita a distorção de dados.

Após ser iniciado, o tempo de mudança de rota será concluído se não houver solicitações AJAX e mutações DOM em andamento. Em seguida, o carimbo de data/hora da última atividade concluída será usado como carimbo de data/hora de conclusão.

O tempo da mudança de rota expirará se houver solicitações AJAX ou mutações DOM em andamento por mais de 10 segundos (por padrão). Nesse caso, o cliente Web do CloudWatch RUM não registrará mais o tempo dessa mudança de rota.

Como resultado, a duração de um evento de mudança de rota é calculada da seguinte forma:

```
(time of latest completed activity) - (latest user interaction timestamp)
```

# Gerenciar suas aplicações que usam o CloudWatch RUM
<a name="CloudWatch-RUM-manage"></a>

Siga as etapas nessas seções para gerenciar o uso do CloudWatch RUM pelas aplicações.

**Topics**
+ [Como encontro um snippet de código que já gerei?](CloudWatch-RUM-find-code-snippet.md)
+ [Edição das configurações do monitor de aplicação do CloudWatch RUM](CloudWatch-RUM-edit-application.md)
+ [Interrupção do uso do CloudWatch RUM ou exclusão de um monitor de aplicação](CloudWatch-RUM-delete-appmonitor.md)

# Como encontro um snippet de código que já gerei?
<a name="CloudWatch-RUM-find-code-snippet"></a>

Para encontrar um snippet de código RUM do CloudWatch que você já gerou para uma aplicação, siga estas etapas.

**Para encontrar um snippet de código que você já gerou**

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 **Application Signals** e, em seguida, **RUM**.

1. Navegue até a guia **Configuração**, seção **Trechos de código**.

1. Escolha **Copiar/baixar** para a instrumentação correspondente.

# Edição das configurações do monitor de aplicação do CloudWatch RUM
<a name="CloudWatch-RUM-edit-application"></a>

Para alterar as configurações de um monitor de aplicações, siga estas etapas. Você pode alterar todas as configurações, exceto o nome do monitor de aplicações.

**Para editar como sua aplicação usa o CloudWatch RUM**

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha o botão ao lado do nome da aplicação e escolha **Actions** (Ações), **Edit** (Editar).

1. Altere todas as configurações, exceto o nome da aplicação. Para obter mais informações sobre as configurações, consulte [Criar um monitor de aplicações do CloudWatch RUM para uma aplicação Web](CloudWatch-RUM-get-started-create-app-monitor.md).

1. Quando terminar, escolha **Save (Salvar)**.

   Alterar as configurações altera o snippet de código. Agora você deve colar o snippet de código atualizado em sua aplicação.

1. Depois que o trecho de código for criado, escolha **Copiar para a área de transferência** ou **Baixar** e depois escolha **Concluído**.

   Para iniciar o monitoramento com as novas configurações, insira o snippet de código em sua aplicação.

# Interrupção do uso do CloudWatch RUM ou exclusão de um monitor de aplicação
<a name="CloudWatch-RUM-delete-appmonitor"></a>

Para parar de usar o CloudWatch RUM com uma aplicação, remova o snippet de código gerado pelo RUM do código da aplicação.

Para excluir um monitor de aplicações do RUM, siga estas etapas.

**Para excluir um monitor de aplicações**

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 **Application Signals** e, em seguida, **RUM**.

1. Escolha o botão ao lado do nome da aplicação e escolha **Actions** (Ações), **Delete** (Excluir).

1. Na caixa de confirmação, insira **Delete** e escolha **Delete** (Excluir).

1. Se você ainda não tiver feito isso, exclua o snippet de código RUM do CloudWatch do código da aplicação.

# Solucionar problemas do CloudWatch RUM
<a name="CloudWatch-RUM-troubleshooting"></a>

Esta seção contém dicas para ajudar na solução de problemas do CloudWatch RUM.

## Não há dados da minha aplicação
<a name="CloudWatch-RUM-troubleshooting-nodata"></a>

Primeiro, verifique se o snippet de código foi inserido corretamente em sua aplicação. Para obter mais informações, consulte [Como inserir o trecho de código do monitor de aplicação do CloudWatch na aplicação](CloudWatch-RUM-get-started-insert-code-snippet.md).

Se esse não for o problema, talvez ainda não tenha havido tráfego para sua aplicação. Gere algum tráfego acessando sua aplicação da mesma forma que um usuário faria.

## Os dados deixaram de ser gravados para a minha aplicação
<a name="CloudWatch-RUM-troubleshooting-nonewdata"></a>

Sua aplicação pode ter sido atualizada e agora não contém mais um snippet de código RUM do CloudWatch. Confira o código da sua aplicação.

Também há a possibilidade de que alguém tenha atualizado o snippet de código, mas não o tenha inserido na aplicação. Encontre o snippet de código correto atual seguindo as instruções em [Como encontro um snippet de código que já gerei?](CloudWatch-RUM-find-code-snippet.md) e compare-o com o snippet de código colado em sua aplicação.