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

Con CloudWatch RUM, puede llevar a cabo una supervisión real de usuarios para recopilar y ver datos del cliente sobre el rendimiento de su aplicación web y móvil desde las sesiones de usuarios reales, casi en tiempo real. En el caso de las aplicaciones web, puede analizar los tiempos de carga de páginas, errores del cliente y comportamiento del usuario. En el caso de las aplicaciones móviles, puede supervisar los tiempos de carga de la pantalla, los tiempos de inicio de las aplicaciones, los errores de red, los bloqueos y los problemas específicos de la plataforma, como aplicaciones de Android que no responden (ANR) y bloqueos de aplicaciones de iOS. Al ver estos datos, puede verlos todos juntos, así como también desgloses por tipos de dispositivo, sistemas operativos y otras características del uso de aplicaciones.

Puede utilizar los datos recopilados para identificar y depurar rápidamente los problemas de rendimiento del lado del cliente. CloudWatch RUM lo ayudará a visualizar anomalías en el rendimiento de la aplicación y a encontrar datos de depuración relevantes, como mensajes de error, seguimientos de pila y sesiones de usuario. También puede utilizar RUM para comprender el intervalo de impacto del usuario final, incluido el número de usuarios, las geolocalizaciones y los navegadores o dispositivos utilizados.

Los datos del usuario final que recopila para CloudWatch RUM se conservan durante 30 días y, a continuación, se eliminan de forma automática. Si desea conservar los datos de telemetría de RUM durante más tiempo, puede elegir que la supervisión de aplicaciones envíe copias de la telemetría a Registros de CloudWatch en la cuenta. A continuación, puede ajustar el periodo de retención de ese grupo de registros.

Si desea usar RUM, cree un *monitor de aplicaciones* y proporcione información. RUM genera un fragmento de código que puede usar para agregar una inyección de dependencias a la aplicación. El fragmento extrae el código del cliente de RUM según sea necesario. El cliente de RUM captura datos de un porcentaje de las sesiones de usuario de la aplicación, que se muestran en un panel prediseñado. Puede especificar el porcentaje de sesiones de usuario del cual desea recopilar datos.

 CloudWatch RUM se integra con [Application Signals](CloudWatch-Application-Monitoring-Sections.md), que puede detectar y supervisar los servicios de aplicaciones, los clientes, los valores controlados de Synthetics y las dependencias de los servicios. Use Application Signals para ver una lista o un mapa visual de sus servicios, ver las métricas del estado en función de los objetivos de nivel de servicio (SLO) y profundizar para ver los seguimientos de X-Ray correlacionados para una solución de problemas más detallada. Para ver las solicitudes de páginas de clientes de RUM en Application Signals, active el seguimiento activo de X-Ray al [crear un monitor de aplicaciones](CloudWatch-RUM-get-started-create-app-monitor.md). En el caso de las aplicaciones web, también puede habilitarlo al [configurar manualmente el cliente web de RUM](CloudWatch-RUM-configure-client.md). Los clientes de RUM se muestran en el [Mapa de aplicaciones](ServiceMap.md) conectado a sus servicios y en la página [Detalles del servicio](ServiceDetail.md) de los servicios a los que llaman. 

Los clientes de RUM son de código abierto. Para obtener más información, consulte el [cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web), el [SDK para Android de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android) y el [SDK para iOS de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-swift).

**Precios de RUM**

Para obtener información acerca de los precios, consulte [Precios de Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). 

**Disponibilidad por región**

Actualmente, CloudWatch RUM está disponible en las siguientes regiones:
+ Este de EE. UU. (Norte de Virginia)
+ Este de EE. UU. (Ohio)
+ Oeste de EE. UU. (Norte de California)
+ Oeste de EE. UU. (Oregón)
+ África (Ciudad del Cabo)
+ AWS GovCloud (Este de EE. UU.)
+ AWS GovCloud (Oeste de EE. UU.)
+ Asia-Pacífico (Mumbai)
+ Asia-Pacífico (Hyderabad)
+ Asia-Pacífico (Melbourne)
+ Asia-Pacífico (Osaka)
+ Asia-Pacífico (Seúl)
+ Asia-Pacífico (Singapur)
+ Asia-Pacífico (Sídney)
+ Asia-Pacífico (Yakarta)
+ Asia-Pacífico (Malasia)
+ Asia-Pacífico (Tailandia)
+ Asia-Pacífico (Tokio)
+ Asia-Pacífico (Hong Kong)
+ Canadá (centro)
+ Europa (Fráncfort)
+ Europa (Irlanda)
+ Europa (Londres)
+ Europa (Milán)
+ Europa (París)
+ Europa (España)
+ Europa (Estocolmo)
+ Europa (Zúrich)
+ AWS European Sovereign Cloud (Alemania)
+ Medio Oriente (Baréin)
+ Medio Oriente (EAU)
+ México (centro)
+ América del Sur (São Paulo)
+ Israel (Tel Aviv)
+ Oeste de Canadá (Calgary)

# Configuración de una aplicación móvil para utilizar CloudWatch RUM
<a name="CloudWatch-RUM-web-mobile"></a>

Para supervisar aplicaciones móviles, se debe crear un monitor de aplicaciones, configurarlo para plataformas móviles e integrar el SDK de AWS Distro para OpenTelemetry (ADOT) en la aplicación. RUM para móviles utiliza el protocolo OpenTelemetry (OTLP) para enviar datos de telemetría a un punto de conexión de OTLP dedicado. 

## Creación de un monitor de aplicaciones para una plataforma móvil
<a name="mobile-platform-app-monitor"></a>

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija **Add app monitor** (Agregar monitor de aplicaciones).

1. En **App monitor name** (Nombre del monitor de aplicaciones), ingrese un nombre que se utilizará para identificar este monitor de aplicaciones en la consola de CloudWatch RUM.

1. Seleccione **Android** o **iOS** como plataforma.

1. En **Almacenamiento de datos**, puede optar por almacenar copias de los eventos e intervalos del registro de OTEL de RUM en Registros de CloudWatch y configurar la retención. El grupo de registros de CloudWatch Logs conserva los datos durante 30 días de forma predeterminada. Puede administrar su periodo de retención de registros en la consola de CloudWatch Logs.

1. (Opcional) En **Política basada en recursos**, elija la opción de agregar una política basada en recursos para controlar quién puede enviar solicitudes al monitor de aplicaciones. Si elige **Crear política pública**, se adjuntará una política de recursos que permitirá a cualquier persona enviar solicitudes al monitor de aplicaciones. Para obtener más información, consulte [Uso de políticas basadas en recursos con CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

1. Para activar los rastros de AWS X-Ray de sesiones de usuarios muestreados, elija **Rastreo activo** y seleccione **Rastrear mi servicio con AWS X-Ray**.

   Si se selecciona, se rastrean los intervalos de OTEL generados durante las sesiones de usuario muestreadas. A continuación, podrá ver los rastros e intervalos de estas sesiones en el panel de RUM y las páginas de detalles de seguimiento y de la asignación de rastros de X-Ray. Estas sesiones del usuario también se mostrarán como páginas de cliente en Application Signals una vez que las haya habilitado para su aplicación.

1. (Opcional) Para agregar etiquetas al monitor de aplicaciones, puede hacer lo siguiente:

   1. Elija **Etiquetas**, **Agregar etiqueta nueva**.

   1. En **Clave**, ingrese un nombre para la etiqueta. Puede agregar un valor opcional en **Valor**.

   1. Para añadir otra etiqueta, vuelva a seleccionar **Agregar nueva etiqueta**.

   Para obtener más información, consulte [Etiquetado de recursos de AWS](https://docs.aws.amazon.com/tagging/latest/userguide/tagging-resources.html) en la *Guía del usuario de etiquetado y el editor de etiquetas de AWS*

1. Elija **Add app monitor** (Agregar monitor de aplicaciones).

1. En la sección **Código de muestra**, puede copiar el fragmento de código que se agregará a la aplicación. Con el SDK de AWS Distro para OpenTelemetry (ADOT), puede elegir entre **Instrumentación manual** para configurar la supervisión en el código de la aplicación o **Instrumentación de código cero** que requiere cambios mínimos en la configuración.

   Tanto en el caso de las aplicaciones para Android como para iOS, la instrumentación de código cero es la opción más sencilla, ya que inicializa automáticamente la recopilación de telemetría mediante un archivo de configuración. La instrumentación manual le da más control sobre el proceso de configuración e inicialización.

1. Elija **Copy** (Copiar) o **Download** (Descargar) y luego elija **Done** (Hecho).

### Configuración para aplicaciones para iOS
<a name="CloudWatch-RUM-ios-setup"></a>

En el caso de las aplicaciones para iOS, integre el [SDK para iOS de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-swift) para activar la supervisión de RUM. El SDK es compatible con iOS 16 y versiones posteriores y proporciona instrumentación automática para escenarios de rendimiento comunes.

### Configuración para aplicaciones para Android
<a name="CloudWatch-RUM-android-setup"></a>

En el caso de las aplicaciones para Android, integre el [SDK para Android de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android) para activar la supervisión de RUM. El SDK proporciona instrumentación automática y admite modelos de autenticación firmados y sin firmar.

## Autenticación y seguridad
<a name="CloudWatch-RUM-authentication"></a>

RUM para móviles admite modelos de autenticación flexibles tal como se definen en sus SDK.
+ La aplicaciones para iOS utilizan el [SDK para iOS de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-swift). 
+ La aplicaciones para Android utilizan el [SDK para Android de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android).

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

Para poder administrar CloudWatch RUM por completo, debe haber iniciado sesión como usuario o rol de IAM que tenga la política de IAM de **AmazonCloudWatchRUMFullAccess** (Acceso completo a Amazon CloudWatch RUM). Además, es posible que necesite otras políticas o permisos:
+ Para crear una supervisión de aplicaciones que cree un nuevo grupo de identidades de Amazon Cognito para obtener autorización, debe tener el rol de IAM de **Admin** (Administrador) o la política de IAM de **AdministratorAccess** (Acceso del administrador).
+ Para crear una supervisión de aplicaciones que envíe datos a CloudWatch Logs, debe iniciar sesión en un rol o política de IAM que tenga los siguientes permisos:

  ```
  {
      "Effect": "Allow",
      "Action": [
          "logs:PutResourcePolicy"
      ],
      "Resource": [
          "*"
      ]
  }
  ```
+ Para habilitar los mapas de origen de JavaScript en el monitor de una aplicación, deberá cargar los archivos de los mapas de origen en un bucket de Amazon S3. Su rol o política de IAM necesita permisos específicos de Amazon S3 que permitan crear buckets de Amazon S3, establecer políticas de bucket y administrar los archivos del bucket. Por motivos de seguridad, limite estos permisos a recursos específicos. El ejemplo de política que aparece a continuación restringe el acceso a los buckets que contienen `rum` en sus nombres y utiliza la clave de condición `aws:ResourceAccount` para limitar los permisos únicamente a la cuenta 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 utilizar sus propias claves de AWS KMS para el cifrado del lado del servidor en su bucket de mapas de origen, su rol o política de IAM necesitará permisos de AWS KMS específicos que permitan crear una clave, actualizar la política de claves, utilizar la clave de AWS KMS con Amazon S3 y establecer la configuración de cifrado de su bucket de Amazon S3. Por motivos de seguridad, limite estos permisos a fines específicos. El siguiente ejemplo restringe el acceso a las claves de una región y accountId específicos, y tiene restricciones de S3 similares a las del ejemplo anterior. 

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

A otros usuarios que necesitan ver los datos de CloudWatch RUM, pero no necesitan crear recursos de CloudWatch RUM, se les puede conceder la política de **AmazonCloudWatchRUMReadOnlyAccess** (Acceso de solo lectura a Amazon CloudWatch RUM).

# Configuración de una aplicación web para utilizar CloudWatch RUM
<a name="CloudWatch-RUM-get-started"></a>

Siga los pasos de estas secciones para configurar la aplicación web con el fin de comenzar a utilizar CloudWatch RUM para recopilar datos de rendimiento de sesiones de usuarios reales.

**Topics**
+ [Autorización a la aplicación web para enviar datos a AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Creación de un monitor de aplicaciones de CloudWatch RUM para una aplicación web](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Modificación del fragmento de código para configurar el cliente web de CloudWatch RUM (opcional)](CloudWatch-RUM-modify-snippet.md)
+ [Inserción del fragmento de código del monitor de aplicaciones de CloudWatch en la aplicación](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Prueba de la configuración del monitor de aplicaciones de CloudWatch mediante la generación de eventos de usuario](CloudWatch-RUM-get-started-generate-data.md)

# Autorización a la aplicación web para enviar datos a AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Tiene cuatro opciones para configurar la autenticación de datos:
+ Use Amazon Cognito y permita que CloudWatch RUM cree un nuevo grupo de identidades de Amazon Cognito para la aplicación. Este método requiere el menor esfuerzo para configurarlo.

  El grupo de identidades contendrá una identidad sin autenticar. Esto permite que el cliente web de CloudWatch RUM envíe datos a CloudWatch RUM sin autenticar al usuario de la aplicación.

  El grupo de identidades de Amazon Cognito tiene un rol de IAM adjunto. La identidad sin autenticar de Amazon Cognito permite que el cliente web asuma el rol de IAM autorizado para enviar datos a CloudWatch RUM.
+ Use Amazon Cognito para la autenticación. Si usa esta opción, puede usar un grupo de identidades de Amazon Cognito existente o crear uno nuevo para usarlo con este monitor de aplicaciones. Si usa un grupo de identidades existente, también debe modificar el rol de IAM que se adjunta al grupo de identidades. Use esta opción para los grupos de identidades que admiten usuarios no autenticados. Solo puede utilizar grupos de identidades dentro de una misma región.
+ Utilice la autenticación de un proveedor de identidades existente que ya haya configurado. En este caso, debe obtener credenciales del proveedor de identidad y la aplicación debe reenviar estas credenciales al cliente web de RUM.

  Use esta opción para los grupos de identidades que solo admiten usuarios autenticados.
+ Utilice políticas basadas en recursos para administrar el acceso al monitor de aplicaciones. Esto incluye la capacidad de enviar solicitudes sin autenticar a CloudWatch RUM sin credenciales de AWS. Para obtener más información sobre las políticas basadas en recursos y RUM, consulte [Uso de políticas basadas en recursos con CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

En las siguientes secciones se detallan estas opciones.

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

Si elige usar un grupo de identidades de Amazon Cognito existente, especifique el grupo de identidades cuando agregue la aplicación a CloudWatch RUM. El grupo debe ser compatible con el acceso a identidades sin autenticar. Solo puede utilizar grupos de identidades dentro de una misma región.

También debe agregar los siguientes permisos a la política de IAM asociada al rol de IAM que está asociado a este 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" 
        }
    ]
}
```

------

Entonces, Amazon Cognito enviará el token de seguridad necesario para permitir que la aplicación tenga acceso a CloudWatch RUM.

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

Si elige utilizar la autenticación privada de un proveedor externo, debe obtener las credenciales del proveedor de identidad y reenviarlas a AWS. La mejor forma de hacerlo es a través de un *proveedor de tokens de seguridad*. Puede utilizar cualquier proveedor de tokens de seguridad, incluido Amazon Cognito con AWS Security Token Service. Para obtener más información sobre AWS STS, consulte [Bienvenido a la referencia sobre las API de AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). 

Si desea utilizar Amazon Cognito como proveedor de tokens en este contexto, puede configurar Amazon Cognito para que funcione con un proveedor de autenticación. Para obtener más información, consulte [Introducción a los grupos de identidades de Amazon Cognito (identidades federadas)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html).

Después de configurar Amazon Cognito para que funcione con su proveedor de identidad, también debe hacer lo siguiente:
+ Cree un rol de IAM con los siguientes permisos. Su aplicación utilizará este rol para acceder a AWS.

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

****  

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

------
+ Agregue lo siguiente a su aplicación para que envíe las credenciales de su proveedor a CloudWatch RUM. Inserte la línea para que se ejecute después de que un usuario haya iniciado sesión en la aplicación y la aplicación haya recibido las credenciales que se utilizarán para acceder a AWS.

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

Para obtener más información acerca de los proveedores de credenciales en JavaScript SDK de AWS, consulte [Configuración de credenciales en un navegador web](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) en la guía para desarrolladores v3 para JavaScript SDK, [Configuración de credenciales en un navegador web](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) en la guía para desarrolladores v2 para JavaScript SDK y [@aws-sdk/credential-providers](https://www.npmjs.com/package/@aws-sdk/credential-providers). 

También puede utilizar el SDK para el cliente web de CloudWatch RUM para configurar los métodos de autenticación del cliente web. Para obtener más información sobre el SDK del cliente web, consulte.[CloudWatch RUM web client SDK](https://github.com/aws-observability/aws-rum-web) (SDK del cliente web de CloudWatch RUM). 

# Creación de un monitor de aplicaciones de CloudWatch RUM para una aplicación web
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Para empezar a utilizar CloudWatch RUM con su aplicación, cree un *spp monitor* (monitor de aplicaciones). Cuando se crea el monitor de aplicaciones, RUM genera un fragmento de código para que lo pegue en su aplicación. El fragmento extrae el código del cliente de RUM. El cliente de RUM captura datos de las sesiones de usuario de la aplicación y los envía a RUM.

## Creación de un monitor de aplicaciones para una plataforma web
<a name="web-platform-app-monitor"></a>

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija **Add app monitor** (Agregar monitor de aplicaciones).

1. En **App monitor name** (Nombre del monitor de aplicaciones), ingrese un nombre que se utilizará para identificar este monitor de aplicaciones en la consola de CloudWatch RUM.

1. Seleccione **Web** como plataforma.

1. En **Lista de dominios de aplicación**, ingrese los nombres de dominio registrados en los que la aplicación tenga autoridad administrativa. También puede usar un carácter comodín `*` para habilitar cualquier subdominio o dominio de nivel superior (por ejemplo, \$1.amazon.com, amazon.\$1, \$1.amazon.\$1).

1. En **Configure RUM data collection** (Configuración de la recopilación de datos de RUM), especifique si desea que el monitor de aplicaciones recopile cada uno de los siguientes elementos:
   + **Telemetría de rendimiento**: recopila información sobre los tiempos de carga de la página y de carga de recursos.
   + **Errores JavaScript**: recopila información sobre los errores de JavaScript no controlados generados por su aplicación.

     Puede seleccionar **Desminificar los seguimientos de pila de errores de JavaScript** para depurar los errores de JavaScript no minificados. Para usar esta característica, cargue los archivos de sus mapas de origen en un bucket o una carpeta de Amazon S3 y proporcione el URI de Amazon S3. Una vez habilitado, RUM utilizará estos mapas de origen y añadirá el seguimiento de pila no minificado para enriquecer los eventos de error de JavaScript. Tenga en cuenta que, una vez habilitada, esta característica solo procesa eventos de error de JavaScript nuevos y no se puede utilizar en datos recopilados anteriormente. Para obtener más información, consulte [Habilitación de la desminificación de seguimientos de pila de errores de JavaScript](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **Errores HTTP**: recopila información sobre los errores HTTP lanzados por la aplicación.

   La selección de estas opciones proporciona más información sobre la aplicación, pero también genera más eventos de CloudWatch RUM y, por lo tanto, incurre en más cargos.

   Si no selecciona ninguno de estos, el monitor de aplicaciones seguirá recopilando eventos de inicio de sesión e ID de página para que pueda ver cuántos usuarios están utilizando la aplicación, incluidos los desgloses por tipo y versión del sistema operativo, tipo y versión del navegador, tipo de dispositivo y ubicación.

1. Seleccione **Check this option to allow the CloudWatch RUM Web Client to set cookies** (Marque esta opción para permitir que el cliente web de CloudWatch RUM configure cookies) si desea poder recopilar ID de usuario e ID de sesión de sesiones de usuario de muestra. Los ID de usuario se generan de forma aleatoria mediante RUM. Para obtener más información, consulte [Cookies del cliente web de CloudWatch RUM (o tecnologías similares)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. En **Session samples** (Muestras de sesiones), ingrese el porcentaje de sesiones de usuario que se utilizarán para recopilar datos de RUM. El valor predeterminado es 100 %. Si reduce este número, obtendrá menos datos, pero reducirá los cargos. Para obtener más información sobre los precios de RUM, consulte [Precios de RUM](CloudWatch-RUM.md#RUMpricing).

1. Los datos del usuario final que recopila para CloudWatch RUM se conservan durante 30 días y, luego, se eliminan. Si desea conservar copias de eventos de RUM en CloudWatch Logs y configurar el tiempo durante el cual se retendrán estas copias, elija **Check this option to store your application telemetry data in your CloudWatch Logs account** (Marque esta opción para almacenar los datos de telemetría de aplicaciones en su cuenta de CloudWatch Logs) en **Data storage** (Almacenamiento de datos). El grupo de registros de CloudWatch Logs conserva los datos durante 30 días de forma predeterminada. Puede administrar su periodo de retención de registros en la consola de CloudWatch Logs.

1. (Opcional) Elija agregar una política basada en recursos al monitor de aplicaciones para controlar quién puede enviar solicitudes `PutRumEvents` al monitor de aplicaciones. Si elige **Crear política pública**, se asociará una política de recursos al monitor de aplicaciones que permitirá a cualquier persona enviar solicitudes `PutRumEvents` al monitor de aplicaciones. Para obtener más información sobre este método, consulte [Uso de políticas basadas en recursos con CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

1. Si adjuntó una política basada en recursos en el paso anterior, no necesitará firmar las solicitudes a CloudWatch RUM con credenciales de AWS, y podrá omitir la configuración de la autorización. De lo contrario, en **Autorización**, especifique si desea utilizar un grupo de identidades de Amazon Cognito nuevo o existente, o utilizar otro proveedor de identidades. Crear un nuevo grupo de identidades es la opción más sencilla ya que no requiere ningún otro paso de configuración. Para obtener más información, consulte [Autorización a la aplicación web para enviar datos a AWS](CloudWatch-RUM-get-started-authorization.md).

   Para llevar a cabo la creación de un nuevo grupo de identidades de Amazon Cognito se necesitan permisos administrativos. Para obtener más información, consulte [Políticas de IAM para utilizar CloudWatch RUM](CloudWatch-RUM-permissions.md).

1. (Opcional) De forma predeterminada, cuando agrega el fragmento de código de RUM a la aplicación, el cliente web inyecta la etiqueta JavaScript para supervisar el uso en el código HTML de todas las páginas de la aplicación. Para cambiar esto, elija **Configure pages** (Configurar páginas) y luego, **Include only these pages** (Incluir solo estas páginas) o **Exclude these pages** (Excluir estas páginas). Luego, especifique las páginas que desea incluir o excluir. Para especificar las páginas que desea incluir o excluir, ingrese las URL completas. Para especificar páginas adicionales, elija **Add URL** (Agregar URL).

1. Para activar el rastreo AWS X-Ray de las sesiones de usuario que el monitor de aplicaciones ofrece como muestra, seleccione **Rastreo activo** y, luego, seleccione **Rastrear mi servicio con AWS X-Ray.**

   Si selecciona esta opción, el monitor de aplicaciones rastreará las solicitudes `XMLHttpRequest` y `fetch` realizadas durante las sesiones de usuario de muestra. A continuación, podrá ver los seguimientos y segmentos de estas sesiones del usuario en el panel de RUM y las páginas de detalles de seguimiento y del mapa de seguimiento de X-Ray. Estas sesiones del usuario también se mostrarán como páginas de cliente en [Application Signals](CloudWatch-Application-Monitoring-Sections.md) una vez que las haya habilitado para su aplicación.

   Al realizar cambios de configuración adicionales en el cliente web de CloudWatch RUM, puede agregar un encabezado de seguimiento de X-Ray a las solicitudes HTTP para habilitar el seguimiento de extremo a extremo de las sesiones de usuario hasta los servicios administrados de AWS. Para obtener más información, consulte [Habilitación del seguimiento integral de X-Ray](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Opcional) Para agregar etiquetas al monitor de aplicaciones, elija **Tags** (Etiquetas), **Add new tag** (Agregar nueva etiqueta).

   Luego, en **Key** (Clave), ingrese un nombre para la etiqueta. Puede agregar un valor opcional para la etiqueta en **Valor**. 

   Para agregar otra etiqueta, vuelva a elegir **Add new tag** (Agregar nueva etiqueta).

   Para obtener más información, consulte [Tagging AWS Resources](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) (Etiquetado de recursos de ).

1. Elija **Add app monitor** (Agregar monitor de aplicaciones).

1. En la sección **Sample code** (Código de muestra), puede copiar el fragmento de código a usar para agregar a la aplicación. Le recomendamos que elija **JavaScript** o **TypeScript** y utilice NPM para instalar el cliente web de CloudWatch RUM como módulo JavaScript.

   De forma alternativa, puede elegir **HTML** para utilizar una red de entrega de contenido (CDN) para instalar el cliente web de CloudWatch RUM. La desventaja de utilizar una CDN es que el cliente web suele estar bloqueado por bloqueadores de anuncios.

1. Elija **Copy** (Copiar) o **Download** (Descargar) y luego elija **Done** (Hecho).

# Modificación del fragmento de código para configurar el cliente web de CloudWatch RUM (opcional)
<a name="CloudWatch-RUM-modify-snippet"></a>

Puede modificar el fragmento de código antes de insertarlo en la aplicación, si desea activar o desactivar varias opciones. Para obtener más información, consulte la [documentación del cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).

Existen cuatro opciones de configuración que definitivamente debe tener en cuenta, como se detalla en estas secciones.

## Impedir la recopilación de URL de recursos que podrían contener información personal
<a name="CloudWatch-RUM-resourceURL"></a>

El cliente web de CloudWatch RUM está configurado de forma predeterminada para registrar las URL de los recursos que se descargan en la aplicación. Estos recursos incluyen archivos HTML, imágenes, archivos CSS, archivos JavaScript, entre otros. En algunas aplicaciones, las URL pueden contener información de identificación personal (PII, por sus siglas en inglés).

Si este es el caso de la aplicación, le recomendamos ampliamente que desactive la recopilación de URL de recursos mediante el uso de `recordResourceUrl: false` en la configuración de fragmentos de código, antes de insertarlo en la aplicación.

## Registro manual de vistas de página
<a name="CloudWatch-RUM-pageload"></a>

El cliente web registra las vistas de página de forma predeterminada cuando se carga la página por primera vez y cuando se llama a la API del historial del navegador. El ID de página predeterminado es `window.location.pathname`. Sin embargo, en algunos casos, es posible que desee anular este comportamiento e instrumentar la aplicación para registrar las visitas a las páginas mediante programación. Si lo hace, podrá controlar el ID de la página y cuándo se registrará. Por ejemplo, pensemos en una aplicación web que tenga un URI con un identificador variable, como `/entity/123` o `/entity/456`. De forma predeterminada, CloudWatch RUM genera un evento de vista de página para cada URI con un ID de página distinto que coincida con el nombre de la ruta, pero es posible que desee agruparlos por el mismo ID de página. Para ello, desactive la automatización de las vistas de página del cliente web mediante la configuración de `disableAutoPageView` y utilice el comando `recordPageView` para establecer el ID de página deseado. Para obtener más información, consulte [Configuraciones específicas de la aplicación](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md) en GitHub.

**Ejemplo de script incrustado:**

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

**Ejemplo de módulo de JavaScript:**

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

## Habilitación del seguimiento integral de X-Ray
<a name="CloudWatch-RUM-xraytraceheader"></a>

Al momento de crear el monitor de aplicaciones, seleccione **Trace my service with AWS X-Ray**; se habilitará el seguimiento de las solicitudes `XMLHttpRequest` y `fetch` hechas durante las sesiones de usuario que el monitor de aplicaciones ofrece como muestra. A continuación, podrá ver los seguimientos de estas solicitudes de HTTP en el panel de CloudWatch RUM y las páginas de detalles de seguimiento y del mapa de seguimiento de X-Ray.

Estos seguimientos del lado del cliente no están conectados a seguimientos posteriores del lado del servidor de forma predeterminada. Para conectar los seguimientos del lado del cliente a los seguimientos del lado del servidor y habilitar el seguimiento de extremo a extremo, establezca la opción `addXRayTraceIdHeader` como `true` (verdadero) en el cliente web. Esto ocasiona que el cliente web de CloudWatch RUM agregue un encabezado de seguimiento de X-Ray a las solicitudes HTTP.

En el siguiente bloque de código, observará un ejemplo de adición de seguimientos del lado del cliente. Algunas opciones de configuración se omiten en este ejemplo para su legibilidad.

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

**aviso**  
La configuración del cliente web de CloudWatch RUM para agregar un encabezado de seguimiento de X-Ray a las solicitudes HTTP puede ocasionar que el uso compartido de recursos de origen cruzado (CORS) falle o invalide la firma de la solicitud si la solicitud está firmada con SigV4. Para obtener más información, consulte la [documentación del cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md). Le recomendamos ampliamente que pruebe la aplicación antes de agregar un encabezado de seguimiento de X-Ray del lado del cliente en un entorno de producción.

Para obtener más información, consulte la [documentación del cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http).

## Envío de solicitudes sin firmar a CloudWatch RUM
<a name="CloudWatch-RUM-unsigned"></a>

De forma predeterminada, el cliente web de RUM firma todas las solicitudes enviadas a RUM. Si establece `signing:false` en la configuración del cliente, las solicitudes no se firmarán cuando se envíen a CloudWatch RUM. Los datos se incorporarán a RUM solo si existe una política pública basada en recursos asociada al monitor de aplicaciones. Para obtener más información, consulte [Uso de políticas basadas en recursos con CloudWatch RUM](CloudWatch-RUM-resource-policies.md).

# Inserción del fragmento de código del monitor de aplicaciones de CloudWatch en la aplicación
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

A continuación, insertará en la aplicación el fragmento de código que haya creado en la sección anterior.

**aviso**  
El cliente web, descargado y configurado mediante el fragmento de código, utiliza cookies (o tecnologías similares) para recopilar datos del usuario final. Antes de insertar el fragmento de código, consulte [Filtrar por atributos de metadatos en la consolaProtección de datos y privacidad de datos con CloudWatch RUM](CloudWatch-RUM-privacy.md).

Si no tiene el fragmento de código que se generó previamente, puede encontrarlo si sigue las instrucciones que se describen en [¿Cómo encuentro un fragmento de código que ya he generado?](CloudWatch-RUM-find-code-snippet.md).

**Para insertar el fragmento de código de CloudWatch RUM en la aplicación**

1. Inserte el fragmento de código que haya copiado o descargado en la sección anterior dentro del elemento `<head>` de la aplicación. Insértelo antes del elemento `<body>` o cualquier otra etiqueta `<script>`.

   El siguiente es un ejemplo de un fragmento de código generado:

   ```
   <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. Si la aplicación es una aplicación web de varias páginas, debe repetir el paso 1 para cada página HTML que desee incluir en la recopilación de datos.

# Prueba de la configuración del monitor de aplicaciones de CloudWatch mediante la generación de eventos de usuario
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Después de insertar el fragmento de código y se esté ejecutando la aplicación actualizada, puede probarlo al generar eventos de usuario de forma manual. Le recomendamos que realice las siguientes acciones. Esta prueba incurre en cargos estándar de CloudWatch RUM.
+ Navegue por las páginas de su aplicación web.
+ Cree varias sesiones de usuario, a través de distintos navegadores y dispositivos.
+ Realice solicitudes.
+ Ocasione errores de JavaScript.

Después de generar algunos eventos, podrá verlos en el panel de CloudWatch RUM. Para obtener más información, consulte [Visualización del panel de CloudWatch RUM](CloudWatch-RUM-view-data.md).

Los datos de las sesiones de usuario pueden tardar hasta 15 minutos en aparecer en el panel.

Si no puede ver los datos 15 minutos después de haber generado eventos en la aplicación, consulte [Solución de problemas de CloudWatch RUM](CloudWatch-RUM-troubleshooting.md).

# Uso de políticas basadas en recursos con CloudWatch RUM
<a name="CloudWatch-RUM-resource-policies"></a>

Puede asociar una política de recursos a un monitor de aplicaciones de CloudWatch RUM. De forma predeterminada, los monitores de aplicaciones no tienen políticas de recursos asociadas. Las políticas basadas en recursos de CloudWatch RUM no admiten el acceso entre cuentas.

Para obtener más información acerca de las políticas de recursos de AWS, consulte [Políticas basadas en identidades y políticas basadas en recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).

Para obtener más información sobre cómo se evalúan las políticas de recursos y las políticas de identidades, consulte [Lógica de evaluación de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html).

Para obtener más información sobre la gramática de las políticas de IAM, consulte [Referencia del elemento de política JSON de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html).

## Acciones admitidas
<a name="RUM-resource-policies-actions"></a>

Las políticas basadas en los recursos de los monitores de aplicaciones admiten la acción `rum:PutRumEvents`.

## Políticas de muestra para utilizar con CloudWatch RUM
<a name="RUM-resource-policies-samples"></a>

El siguiente ejemplo permite que cualquier persona escriba datos en el monitor de aplicaciones, incluidas aquellas que no tengan credenciales de 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": "*"
        }
    ]
}
```

------

Puede modificar la política para bloquear direcciones IP de origen específicas mediante la clave de condición `aws:SourceIp`. Con este ejemplo, si se utiliza esta política, se rechazarán los PutRumEvents procedentes de la dirección IP indicada. Se aceptarán el resto de solicitudes procedentes de otras direcciones IP. Para obtener más información sobre esta clave de condición, consulte [Propiedades de la red](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-network-properties) en la Guía del usuario de 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"
                }
            }
        }
    ]
}
```

------

Además, puede utilizar la clave de contexto del servicio `rum:alias` para controlar qué solicitudes se aceptan. 

En el caso de los monitores de aplicaciones web, debe configurar el cliente web de modo que envíe `Alias` con la versión 1.20 o posterior del cliente web de CloudWatch RUM, como se describe en [Application-specific Configurations](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md) en GitHub.

En el caso de los monitores de aplicaciones móviles, debe configurar la instrumentación de acuerdo con el SDK.
+ La aplicaciones para iOS utilizan el [SDK para iOS de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-swift). 
+ La aplicaciones para Android utilizan el [SDK para Android de AWS Distro para OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android).

En el siguiente ejemplo, la política de recursos requiere que las solicitudes contengan `alias1` o `alias2` para que se acepte el evento.

```
    {
    "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"]
                }
            }
        }
    ]
}
```

# Configuración del cliente web de CloudWatch RUM
<a name="CloudWatch-RUM-configure-client"></a>

Las aplicaciones podrán utilizar uno de los fragmentos de código que haya generado CloudWatch RUM para instalar el cliente web de CloudWatch RUM. Los fragmentos generados admiten dos métodos de instalación: como módulo JavaScript a través de NPM o desde una red de entrega de contenido (CDN). Para obtener el máximo desempeño, le recomendamos utilizar el método de instalación de NPM. Para obtener más información sobre cómo utilizar este método, consulte [Instalación como módulo JavaScript](https://github.com/aws-observability/aws-rum-web/blob/main/docs/npm_installation.md).

Si utiliza la opción de instalación de CDN, los bloqueadores de anuncios podrían bloquear la CDN predeterminada proporcionada por CloudWatch RUM. Esto deshabilita la supervisión de aplicaciones para los usuarios que tienen bloqueadores de anuncios instalados. Por ello, le recomendamos que utilice la CDN predeterminada solo para la incorporación inicial con CloudWatch RUM. Para obtener más información sobre cómo mitigar este problema, consulte [Instrumentar la aplicación](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#instrument-the-application).

El fragmento de código se encuentra en la etiqueta `<head>` de un archivo HTML e instala el cliente web mediante la descarga del cliente web y su configuración para la aplicación que está supervisando. El fragmento es una función de ejecución automática que tiene un aspecto similar a lo que se detalla a continuación. En este ejemplo, se omite el cuerpo de la función del fragmento por motivos de legibilidad.

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

El fragmento de código acepta seis argumentos:
+ un espacio de nombres para ejecutar comandos en el cliente web, como `'cwr'`
+ el ID del monitor de aplicaciones, como `'00000000-0000-0000-0000-000000000000'`
+ la versión de la aplicación, como `'1.0.0'`
+ la región de AWSdel monitor de aplicaciones, como `'us-west-2'`
+ la URL del cliente web, como `'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js'`
+ opciones de configuración específicas de la aplicación. Para más información, consulte la siguiente sección.

## Ignoración de errores
<a name="CloudWatch-RUM-configure-ignore-errors"></a>

El cliente web CloudWatch RUM escucha todo tipo de errores que se producen en sus aplicaciones. Si su aplicación emite errores de JavaScript que no desea ver en el panel de CloudWatch RUM, puede configurar el cliente web de CloudWatch RUM para que filtre tales errores, de modo que solo le aparezcan los eventos de error relevantes en el panel de CloudWatch RUM. Por ejemplo, puede optar por no ver algunos errores de JavaScript en el panel porque ya ha identificado una solución para ellos y el volumen de tales errores oculta otros errores. También puede ignorar los errores que no pueda corregir porque pertenezcan a una biblioteca que sea propiedad de un tercero.

Para obtener más información sobre cómo instrumentar al cliente web para que filtre errores específicos de JavaScript, consulte el ejemplo de [Errors](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md#errors) (Errores) en la documentación de Github del cliente web.

## Opciones de configuración
<a name="CloudWatch-RUM-configure-options"></a>

Para obtener información sobre las opciones de configuración disponibles para el cliente web de CloudWatch RUM, consulte la [documentación del cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md).

# Habilitación de la desminificación de seguimientos de pila de errores de JavaScript
<a name="CloudWatch-RUM-JavaScriptStackTraceSourceMaps"></a>

Cuando el código fuente JavaScript de la aplicación web está minificado, los seguimientos de pila de los errores pueden resultar difíciles de leer. Para habilitar la desminificación de los seguimientos de pila, puede cargar sus mapas de origen en Amazon S3. CloudWatch RUM recuperará los mapas de origen para vincular los números de línea y columna del código fuente minificado con el código fuente original no minificado. Esto mejorará la legibilidad de los seguimientos de pila de los errores y ayudará a identificar la ubicación del error en el código fuente original. 

## Requisitos y sintaxis
<a name="CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps"></a>

Los mapas de origen son fundamentales para depurar y hacer un seguimiento de los problemas de la aplicación web en las distintas versiones. Asegúrese de que cada versión de la aplicación web tenga un mapa de origen único. Cada versión debería tener su propio releaseId único. El releaseId debe ser una cadena de entre 1 y 200 caracteres y solo puede contener letras, números, guiones bajos, guiones, dos puntos, barras y puntos. Para añadir el `releaseId` como metadato a los eventos de RUM, configure el cliente web de CloudWatch RUM.

Se espera que los mapas de origen sean archivos JSON simples que sigan la estructura definida por la [especificación Source Map V3](https://sourcemaps.info/spec.html). Los campos obligatorios son `version`, `file`, `sources`, `names` y `mappings`.

Asegúrese de que el tamaño de cada mapa de origen no supere el límite de 50 MB. Además, el servicio RUM solo recuperará hasta 50 MB de mapas de origen por seguimiento de pila. Si es necesario, divida el código fuente en varios fragmentos más pequeños. Para obtener más información, consulte [División de código con WebpackJS](https://webpack.js.org/guides/code-splitting/).

**Topics**
+ [Requisitos y sintaxis](#CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps)
+ [Configuración de la política de recursos de su bucket de Amazon S3 para permitir el acceso al servicio RUM](#CloudWatch-RUM-ConfigureS3)
+ [Carga de mapas de origen](#CloudWatch-RUM-UploadSourceMaps)
+ [Configuración del releaseId en el cliente web de CloudWatch RUM](#CloudWatch-RUM-ConfigureRumID)
+ [Habilitación del monitor de aplicaciones CloudWatch RUM para desminificar los seguimientos de pila de JavaScript](#CloudWatch-RUM-unminifyjavascript)
+ [Visualización de seguimientos de pila desminificados en la consola de RUM](#CloudWatch-RUM-viewunminifiedstacktraces)
+ [Visualización de los seguimientos de pila sin minificar en CloudWatch Logs](#CloudWatch-RUM-viewunminifiedstacktracesCWL)
+ [Solución de problemas con los mapas de origen](#CloudWatch-RUM-troubleshootsourcemaps)

## Configuración de la política de recursos de su bucket de Amazon S3 para permitir el acceso al servicio RUM
<a name="CloudWatch-RUM-ConfigureS3"></a>

Asegúrese de que su bucket de Amazon S3 se encuentre en la misma región que su appMonitor de RUM. Configure su bucket de Amazon S3 para permitir el acceso al servicio RUM para recuperar los archivos de mapas de origen. Incluya las claves de contexto de condición globales `aws:SourceArn` y `aws:SourceAccount` para limitar los permisos del servicio al recurso. Esta es la forma más eficaz de protegerse contra el [problema del suplente confuso](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).

En el ejemplo siguiente se muestra cómo se pueden utilizar las claves de contexto de condición globales `aws:SourceArn` y `aws:SourceAccount` en Amazon S3 para evitar el problema del suplente 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"
                }
            }
        }
    ]
}
```

------

Si utiliza claves de AWS KMS para cifrar los datos, asegúrese de que la política de recursos de la clave esté configurada de manera similar para incluir las claves de contexto de condición globales `aws:SourceArn` y `aws:SourceAccount` con el fin de dar acceso al servicio RUM para usar las claves y recuperar los archivos de los mapas de origen.

------
#### [ 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"
                }
            }
        }
    ]
}
```

------

## Carga de mapas de origen
<a name="CloudWatch-RUM-UploadSourceMaps"></a>

Configure su paquete de JavaScript para generar mapas de origen durante la minificación. Cuando cree su aplicación, el paquete creará un directorio (por ejemplo, dist) que contiene los archivos JavaScript minificados y sus mapas de origen correspondientes. Consulte a continuación un ejemplo.

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

Cargue los archivos de los mapas de origen en el bucket de Amazon S3. Los archivos deben estar ubicados en una carpeta con el `releaseId` como nombre. Por ejemplo, si el nombre de mi bucket es `my-application-source-maps` y el `releaseId` es 2.0.0, significa que el archivo del mapa de origen se encuentra en la siguiente ubicación:

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

Para automatizar la carga de los mapas de origen, puede crear el siguiente script Bash y ejecutarlo como parte de su proceso de creación.

```
#!/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
```

## Configuración del releaseId en el cliente web de CloudWatch RUM
<a name="CloudWatch-RUM-ConfigureRumID"></a>

CloudWatch RUM utiliza el `releaseId` configurado para determinar la carpeta de la que recuperar los archivos de los mapas de origen. Asigne al `releaseId` el mismo nombre que a la carpeta de archivos de mapas de origen. Si usó el script Bash proporcionado anteriormente o uno similar, el `releaseId` configurado en el script debe ser el mismo que el configurado en su cliente web de CloudWatch RUM. Debe utilizar la versión 1.21.0 o posterior del cliente web de 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
}
```

## Habilitación del monitor de aplicaciones CloudWatch RUM para desminificar los seguimientos de pila de JavaScript
<a name="CloudWatch-RUM-unminifyjavascript"></a>

Para desminificar los seguimientos de pila de JavaScript, establezca el estado SourceMap del monitor de aplicaciones en `ENABLED`. Proporcione el URI de Amazon S3 del bucket o la carpeta que contiene todos los mapas de origen para el monitor de su aplicación.

Si se almacenan los mapas de origen directamente en el bucket principal (no en una subcarpeta), el URI de Amazon S3 debe tener el formato `Amazon S3://BUCKET_NAME`. En este caso, los archivos de los mapas de origen deben estar en la siguiente ubicación.

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

Cuando la raíz es un directorio secundario, el formato del URI de Amazon S3 debe ser `Amazon S3://BUCKET_NAME/DIRECTORY`. En este caso, los archivos de los mapas de origen deben estar en la siguiente ubicación.

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

## Visualización de seguimientos de pila desminificados en la consola de RUM
<a name="CloudWatch-RUM-viewunminifiedstacktraces"></a>

Después de cargar los mapas de origen en Amazon S3, habilitar los mapas de origen en el monitor de aplicaciones RUM e implementar la aplicación web con el `releaseId` configurado en el cliente web de CloudWatch RUM, seleccione **Eventos** en la consola de RUM. En esta pestaña se muestran los datos sin procesar de los eventos de RUM. Filtre los datos por el tipo de evento de error de JS y vea el último evento de error de JS. Verá el seguimiento de pila sin minificar en el nuevo campo `event_details.unminifiedStack` correspondiente a los eventos ingeridos después de habilitar la característica.

## Visualización de los seguimientos de pila sin minificar en CloudWatch Logs
<a name="CloudWatch-RUM-viewunminifiedstacktracesCWL"></a>

Para habilitar el almacenamiento de eventos de RUM en CloudWatch Logs, active el **Almacenamiento de datos**. Una vez habilitado, puede buscar en el nuevo campo **event\$1details.unminifiedStack**. Esto le permite analizar las tendencias y relacionar los problemas de varias sesiones con las consultas de CloudWatch Logs.

## Solución de problemas con los mapas de origen
<a name="CloudWatch-RUM-troubleshootsourcemaps"></a>

CloudWatch RUM proporciona métricas listas para usar para solucionar los problemas de configuración de los mapas de origen. Estas métricas se publican en el espacio de nombres de la métrica llamado `AWS/RUM`. Las métricas siguientes se publican con una dimensión de application\$1name. El valor de esta dimensión es el nombre del supervisor de aplicaciones. Las métricas también se publican con una dimensión de `aws:releaseId`. El valor de esta dimensión es el `releaseId` asociado al evento de error de JavaScript.


| MetricName | Unidad | Descripción | 
| --- | --- | --- | 
|  UnminifyLineFailureCount  |  Recuento  |  El recuento de líneas de seguimiento de pila en el evento de error de JS que no se pudo desminificar. Se agregarán detalles adicionales sobre el error a la línea específica que falló en el campo event\$1details.unminifiedStack.  | 
|  UnminifyLineSuccessCount  |  Recuento  | El recuento de líneas de seguimiento de pila en el evento de error de JS que se desminificaron correctamente. | 
| UnminifyEventFailureCount | Recuento | El recuento de eventos de error de JS en los que no se pudo desminificar ninguna línea. Se agregarán detalles adicionales sobre el error en el campo event\$1details.unminifiedStack. | 
| UnminifyEventSuccessCount | Recuento | El recuento de eventos de error de JS en los que se logró desminificar al menos una línea de seguimiento de pila. | 

Es posible que CloudWatch RUM no pueda desminificar alguna línea del seguimiento de pila por diferentes motivos, entre los que se incluyen los siguientes:
+ No se pudo recuperar el archivo del mapa de origen correspondiente debido a problemas con los permisos. Asegúrese de que la política de recursos del bucket esté configurada correctamente.
+ El archivo del mapa de origen correspondiente no existe. Asegúrese de que los archivos de los mapas de origen se hayan cargado en el bucket o la carpeta correctos con el mismo nombre que el releaseId configurado en el cliente web de CloudWatch RUM.
+ El archivo del mapa de origen correspondiente es demasiado grande. Divida el código fuente en fragmentos más pequeños.
+ Ya se han recuperado 50 MB de archivos de mapas de origen para el seguimiento de pila. Reduzca la longitud del seguimiento de pila, ya que 50 MB es una limitación del lado del servicio.
+ El mapa de origen no es válido y no se pudo indexar. Asegúrese de que el mapa de origen sea un archivo JSON simple que siga la estructura definida por la especificación Source Map V3 e incluya los siguientes campos: version, file, sources, names y mappings.
+ El mapa de origen no pudo vincular el código fuente minificado con el seguimiento de pila no minificado. Asegúrese de que el mapa de origen sea el mapa de origen correcto para el releaseId indicado.

# Regionalización
<a name="CloudWatch-RUM-Regionalization"></a>

En esta sección, se ilustran las estrategias para utilizar CloudWatch RUM con aplicaciones de diferentes regiones.

## Mi aplicación está implementada en varias regiones de AWS
<a name="CloudWatch-RUM-Regionalization-multiple"></a>

Si su aplicación se implementa en varias regiones de AWS, tiene tres opciones:
+ Implemente un monitor de aplicaciones en una región, en una cuenta, para que sirva a todas las regiones.
+ Implemente monitores de aplicaciones independientes para cada región, en cuentas únicas.
+ Implemente monitores de aplicaciones independientes para cada región, en cuentas únicas.

La ventaja de usar un monitor de aplicaciones es que todos los datos se centralizan en una visualización y todos los registros se escriben en el mismo grupo de registro en registros de CloudWatch. Con un único monitor de aplicaciones existe una pequeña cantidad de latencia adicional para las solicitudes y un único punto de error.

Usar varios monitores de aplicaciones elimina el punto único de error, pero evita que todos los datos se combinen en una sola visualización.

### CloudWatch RUM no se ha lanzado en algunas regiones en las que está implementada mi aplicación
<a name="CloudWatch-RUM-Regionalization-notavailable"></a>

CloudWatch RUM se ha lanzado en muchas regiones y tiene una amplia cobertura geográfica. Si configura CloudWatch RUM en las regiones en las que está disponible, podrá disfrutar de sus ventajas. Los usuarios finales pueden estar en cualquier lugar y seguir teniendo sus sesiones incluidas si ha configurado un monitor de aplicaciones en la región a la que se conectan.

Sin embargo, CloudWatch RUM aún no se ha lanzado en ninguna región de China. No puede enviar datos a CloudWatch RUM desde estas regiones.

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

Use grupos de páginas para asociar páginas diferentes de su aplicación entre sí, de modo que pueda ver los análisis agregados de los grupos de páginas. Por ejemplo, es posible que desee ver los tiempos de carga de páginas agregados de todas sus páginas de destino. 

Para colocar páginas en grupos de páginas, agregue una o más etiquetas a los eventos de visualización de página en el cliente web de CloudWatch RUM. Los siguientes ejemplos ponen la página `/home` en el grupo de páginas denominado `en` y el grupo de páginas denominado `landing`.

**Ejemplo de script incrustado**

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

**Ejemplo de módulo de JavaScript**

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

**nota**  
Los grupos de páginas están diseñados para hacer más fácil agregar análisis en diferentes páginas. Para obtener información sobre cómo definir y manipular `pageIds` para su aplicación, consulte la sección **Registro manual de las visitas a las páginas** en [Modificación del fragmento de código para configurar el cliente web de CloudWatch RUM (opcional)](CloudWatch-RUM-modify-snippet.md).

# Especificación de metadatos personalizados
<a name="CloudWatch-RUM-custom-metadata"></a>

CloudWatch RUM adjunta datos adicionales a cada evento en forma de metadatos. Los metadatos de eventos constan de atributos en forma de pares clave-valor. Puede usar estos atributos para buscar o filtrar eventos en la consola de CloudWatch RUM. De forma predeterminada, CloudWatch RUM crea algunos metadatos que puede usar. Para obtener más información acerca de los metadatos predeterminados, consulte [Metadatos del evento de RUM](CloudWatch-RUM-datacollected.md#CloudWatch-RUM-datacollected-metadata).

También puede utilizar el cliente web de CloudWatch RUM para agregar metadatos personalizados a los eventos de CloudWatch RUM. Algunos metadatos personalizados pueden ser atributos de sesión y atributos de página.

Para agregar metadatos personalizados, debe utilizar la versión 1.10.0 o posterior del cliente web de CloudWatch RUM.

## Requisitos y sintaxis
<a name="CloudWatch-RUM-custom-metadata-syntax"></a>

Cada evento puede incluir hasta 10 atributos personalizados en los metadatos. Los requisitos de sintaxis para los atributos personalizados son los siguientes:
+ **Claves**
  + Máximo de 128 caracteres
  + Puede contener caracteres alfanuméricos, caracteres de dos puntos (:) y guiones bajos (\$1).
  + No puede empezar por `aws:`.
  + No puede constar exclusivamente de ninguna de las palabras clave reservadas que figuren en la siguiente sección. Puede usar esas palabras clave como parte de un nombre de clave más largo.
+ **Valores**
  + Máximo de 256 caracteres
  + Deben ser cadenas, números o valores booleanos

**Palabras clave reservadas**

No puede utilizar las siguientes palabras clave reservadas como nombres de clave completos. Puede utilizar las siguientes palabras clave como parte de un nombre de clave más largo, por ejemplo `applicationVersion`.
+ `browserLanguage`
+ `browserName`
+ `browserVersion`
+ `countryCode`
+ `deviceType`
+ `domain`
+ `interaction`
+ `osName`
+ `osVersion`
+ `pageId`
+ `pageTags`
+ `pageTitle`
+ `pageUrl`
+ `parentPageId`
+ `platformType`
+ `referrerUrl`
+ `subdivisionCode`
+ `title`
+ `url`
+ `version`

**nota**  
CloudWatch RUM elimina los atributos personalizados de los eventos de RUM si un atributo incluye una clave o un valor inválido, o si ya se ha alcanzado el límite de 10 atributos personalizados por evento. 

## Adición de atributos de sesión
<a name="CloudWatch-RUM-session-attributes"></a>

Si configura atributos de sesión personalizados, se agregan a todos los eventos de una sesión. Los atributos de sesión se configuran durante la inicialización del cliente web de CloudWatch RUM o en tiempo de ejecución mediante el comando `addSessionAttributes`.

Por ejemplo, puede agregar la versión de su aplicación como un atributo de sesión. A continuación, en la consola de CloudWatch RUM, puede filtrar los errores por versión para ver si hay un aumento en la tasa de errores asociado a una versión concreta de la aplicación. 

**Agregar un atributo de sesión en la inicialización, ejemplo de NPM**

La sección de código en negrita agrega el atributo de sesión.

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

**Agregar un atributo de sesión en tiempo de ejecución, ejemplo de NPM**

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

**Agregar un atributo de sesión en la inicialización, ejemplo de script incrustado**

La sección de código en negrita agrega el atributo de sesión.

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

**Agregar un atributo de sesión en tiempo de ejecución, ejemplo de script incrustado**

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

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

Si configura atributos de página personalizados, se agregan a todos los eventos de la página actual. Los atributos de página se configuran durante la inicialización del cliente web de CloudWatch RUM o en tiempo de ejecución mediante el comando `recordPageView`.

Por ejemplo, puede agregar una plantilla de página como un atributo de página. A continuación, en la consola de CloudWatch RUM, puede filtrar los errores por plantillas de página para ver si hay un aumento en la tasa de errores asociado a una plantilla de página concreta de la aplicación. 

**Agregar un atributo de página en la inicialización, ejemplo de NPM**

La sección de código en negrita agrega el 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);
```

**Agregar un atributo de página en tiempo de ejecución, ejemplo de NPM**

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

**Agregar un atributo de página en la inicialización, ejemplo de script incrustado**

La sección de código en negrita agrega el 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>
```

**Agregar un atributo de página en tiempo de ejecución, ejemplo de script incrustado**

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

## Filtrar por atributos de metadatos en la consola
<a name="CloudWatch-RUM-custom-attiributes-console"></a>

Para filtrar las visualizaciones en la consola de CloudWatch RUM con cualquier atributo de metadatos integrado o personalizado, utilice la barra de búsqueda. En la barra de búsqueda, puede especificar hasta 20 términos de filtro en forma de **clave=valor** para aplicarlos a las visualizaciones. Por ejemplo, para filtrar datos únicamente para el navegador Chrome, puede añadir el término de filtro **browserName=Chrome**.

De forma predeterminada, la consola RUM de CloudWatch recupera los 100 atributos, claves y valores más comunes para mostrarlos en el menú desplegable de la barra de búsqueda. Para agregar más atributos de metadatos como términos de filtro, ingresa la clave y el valor del atributo completos en la barra de búsqueda. 

Un filtro puede incluir hasta 20 términos de filtro y puede guardar hasta 20 filtros por monitor de aplicación. Al guardar un filtro, se guarda en el menú desplegable **Saved filters** (Filtros guardados). También puede eliminar un filtro guardado. 

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

CloudWatch RUM graba e ingiere los eventos que se enumeran en [Información recopilada por el cliente web de CloudWatch RUM](CloudWatch-RUM-datacollected.md). Si usa la versión 1.12.0 o posterior del cliente web de CloudWatch RUM, puede definir, registrar y enviar eventos personalizados adicionales. Defina el nombre del tipo de evento y los datos que se van a enviar para cada tipo de evento que defina. La carga útil de cada evento personalizado puede tener un máximo de 6 KB.

Los eventos personalizados se incorporan solo si el monitor de aplicaciones tiene activados los eventos personalizados. Para actualizar los ajustes de configuración del monitor de aplicaciones, utilice la consola CloudWatch RUM o la API [UpdateAppMonitor](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_UpdateAppMonitor.html). 

Después de habilitar los eventos personalizados y, a continuación, de definir y enviar eventos personalizados, puede buscarlos. Para buscarlos, utilice la pestaña **Events** (Eventos) de la consola de CloudWatch RUM. Busque mediante el tipo de evento.

## Requisitos y sintaxis
<a name="CloudWatch-RUM-custom-event-syntax"></a>

Los eventos personalizados constan de un tipo de evento y detalles del evento. Los requisitos son los siguientes:
+ **Tipo de evento**
  + Puede ser el **type** (tipo) o el **name** (nombre) del evento. Por ejemplo, el tipo de evento integrado de CloudWatch RUM denominado **JsError** tiene un tipo de evento de `com.amazon.rum.js_error_event`.
  + Debe tener entre 1 y 256 caracteres de longitud.
  + Puede ser una combinación de caracteres alfanuméricos, guiones bajos, guiones cortos y puntos.
+ **Detalles del evento**
  + Contiene los datos reales que desee registrar en CloudWatch RUM.
  + Debe ser un objeto que conste de campos y valores.

## Ejemplos de grabación de eventos personalizados
<a name="CloudWatch-RUM-custom-event-examples"></a>

Hay dos formas de grabar eventos personalizados en el cliente web de CloudWatch RUM. 
+ Utilice la API `recordEvent` del cliente web de CloudWatch RUM.
+ Utilice un complemento personalizado.

**Enviar un evento personalizado mediante la API `recordEvent`, ejemplo 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 un evento personalizado mediante la API `recordEvent`, ejemplo de script incrustado**

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

**Ejemplo de envío de un evento personalizado mediante un complemento 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);
    }
}
```

# Visualización del panel de CloudWatch RUM
<a name="CloudWatch-RUM-view-data"></a>

CloudWatch RUM le permite recopilar datos de las sesiones de usuario sobre el rendimiento de la aplicación, incluidos los tiempos de carga, la puntuación de Apdex, la información del dispositivo, la geolocalización de las sesiones de usuario y las sesiones con errores. Toda esta información se muestra en un panel.

Para ver el panel de RUM, haga lo siguiente:

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

La consola de RUM muestra una vista de lista de todos los monitores de aplicaciones. La columna **Plataforma** indica si cada monitor de aplicaciones es para aplicaciones web, para Android o para iOS. Seleccione un monitor de aplicaciones para acceder a vistas detalladas con las pestañas **Rendimiento**, **Errores**, **Sesiones**, **Métricas** y **Configuración**.

## Panel de la aplicación web
<a name="CloudWatch-RUM-web-dashboard"></a>

Al seleccionar un monitor de aplicaciones web, verá las siguientes pestañas:
+ En la pestaña **Performance** se muestra información sobre el rendimiento de la página, lo que incluye los tiempos de carga, la información de la solicitud, los elementos vitales web y las cargas de la página en el tiempo. Esta vista incluye gráficos interactivos de elementos vitales web en los que puede ver los diferentes valores percentiles de los elementos vitales web de sus páginas y elegir puntos de datos en el gráfico para ver los eventos asociados que captura CloudWatch RUM. Desde allí, puede explorar más eventos relacionados con el pico de las métricas o ver los detalles de la página de un evento seleccionado para identificar las condiciones específicas que causan problemas de rendimiento.

  En esta pestaña, también puede cambiar la vista entre **Cargas de la página**, **Solicitudes** y **Ubicación** para ver más detalles sobre el rendimiento de la página.
+ En la pestaña **Errores** se muestra información sobre los errores de Javascript, incluido el mensaje de error que ven con más frecuencia los usuarios y los dispositivos y navegadores con más errores. Esta vista incluye un histograma de los errores y una vista de lista de los errores. Puede filtrar la lista de errores por usuario y detalles del evento. Seleccione un mensaje de error para ver más detalles.
+ La pestaña de **solicitudes HTTP** muestra la información de las solicitudes HTTP, incluida la URL de la solicitud con más errores y los dispositivos y navegadores con más errores. Esta pestaña incluye un histograma de las solicitudes, una vista de lista de las solicitudes y una vista de lista de los errores de red. Puede filtrar las listas por usuario y detalles del evento. Elija un código de respuesta o un mensaje de error para ver más detalles sobre la solicitud o el error de red, respectivamente.
+ La pestaña **Sesiones** muestra las métricas de la sesión. Esta pestaña incluye un histograma de los eventos de inicio de sesión y una vista de lista de las sesiones. Puede filtrar la lista de sesiones por tipo de evento, detalles de usuario y detalles del evento. Elija un **SessionID** para ver más detalles sobre una sesión.
+ La pestaña **Eventos** muestra un histograma de los eventos de RUM y una vista de lista de los eventos. Puede filtrar la lista de eventos por tipo de evento, detalles de usuario y detalles del evento. Elija un evento RUM para ver el evento sin procesar.
+ En la pestaña de **Browsers & Devices** (Navegadores y dispositivos) se muestra información como el rendimiento y el uso de distintos navegadores y dispositivos para acceder a la aplicación. Esta vista incluye controles para alternar la vista entre **Navegadores** y **Dispositivos**.

  Si limita el alcance a un solo navegador, verá los datos desglosados por versión del navegador.
+ En la pestaña de **User Journey** (Recorrido del usuario) se muestran las rutas que utilizan los clientes para navegar por la aplicación. Puede ver dónde ingresan los clientes en la aplicación y de qué página salen de la aplicación. También puedes ver las rutas que toman y el porcentaje de clientes que siguen esas rutas. Puede detenerse en un nodo para obtener más detalles sobre esa página. Puede elegir una única ruta para resaltar las conexiones y facilitar la visualización.
+  La pestaña **Métricas** muestra todas las métricas predeterminadas de CloudWatch publicadas por el monitor de aplicaciones, lo que incluye los elementos vitales web de rendimiento, las métricas de errores (errores de JavaScript, errores o fallos de HTTP), el volumen, el flujo de usuarios y las métricas de apdex. Si ha creado métricas ampliadas para la aplicación, la pestaña también incluye un subconjunto de estas métricas en la sección de métricas ampliadas. Este subconjunto incluye métricas de tipo PageViewCount, PerformanceNavigationDuration, Http4xxCount, Http5xxCount y JsErrorCount. El panel muestra tres variaciones de métricas por tipo de métrica. Como se trata de métricas de CloudWatch, también puede exportar esta pestaña a su propio panel mediante la opción **Agregar al panel** y actualizarla para incluir más métricas. 

(Opcional) En cualquiera de las seis primeras pestañas, puede elegir el botón **Páginas** y seleccionar una página o un grupo de páginas de la lista. Esto reduce los datos que se muestran a una sola página o grupos de páginas de la aplicación. También puede marcar las páginas o grupos de páginas de la lista como favoritas.

## Panel de la aplicación móvil
<a name="CloudWatch-RUM-mobile-dashboard"></a>

Al seleccionar un monitor de aplicaciones móviles, verá las siguientes pestañas:
+ La pestaña **Rendimiento** proporciona información sobre el rendimiento de la aplicación móvil, lo que incluye los tiempos de cargas de pantalla, los tiempos de lanzamiento de aplicaciones (en frío y en caliente), las métricas de rendimiento y las puntuaciones de Apdex a lo largo del tiempo. La vista detallada desglosa el rendimiento por nombres de pantalla, versiones del sistema operativo, versiones de la aplicación, dispositivos y países. Al hacer clic en un tiempo de carga de la pantalla, tiempo de lanzamiento de la aplicación o punto de datos de ubicación en el gráfico, se abrirá el panel de diagnóstico de la derecha que proporciona más información pertinente para el punto de datos que consiste en las sesiones y los enlaces correlacionados más recientes en la pestaña **Sesiones** para la solución de problemas.

  En esta pestaña, también puede cambiar la vista entre **Cargas de pantalla**, **Lanzamientos de aplicaciones** y **Ubicación** para ver más detalles sobre el rendimiento de la página.

  La pestaña también incluye la puntuación del índice de rendimiento de la aplicación (Apdex) que indica el nivel de satisfacción de los usuarios finales. Las puntuaciones oscilan entre 0 (menos satisfechos) y 1 (más satisfechos). Las puntuaciones se basan únicamente en el rendimiento de la aplicación. Para obtener más información sobre las puntuaciones de Apdex, consulte [Cómo establece CloudWatch RUM las puntuaciones de Apdex](#CloudWatch-RUM-apdex).
+ La pestaña **Errores** desglosa los problemas de las aplicaciones en tres categorías: errores de red, bloqueos y ANR (Android) o bloqueos de aplicaciones (iOS). La pestaña **Errores de red** tiene un gráfico de líneas que muestra la latencia de la red, los errores del cliente (código de estado 4xx) y los errores del servidor (código de estado 5xx). Al hacer clic en un punto de datos de cualquiera de estas líneas del gráfico, se abrirá el panel de diagnóstico. La tabla inferior muestra las 100 rutas de red más comunes. Al hacer clic en un botón de radio, se filtrará el gráfico de líneas por la ruta de red seleccionada.

  Del mismo modo, las pestañas **Bloqueos** y **ANR o Bloqueos de aplicaciones** muestran una serie de líneas para el recuento de cada error, que son intratables. La tabla inferior muestra el mensaje de bloqueo superior más común o el rastro de pila de bloqueos de aplicaciones o ANR. Al hacer clic en un botón de radio, se filtrará el gráfico y, al hacer clic en el mensaje de error, se mostrará el rastro completo de la pila.
+ La pestaña **Sesiones** muestra una tabla con todas las sesiones en orden cronológico descendente. En la parte inferior, una visualización en cascada muestra toda la telemetría de la sesión seleccionada, lo que le permite hacer un seguimiento de las interacciones de los usuarios e identificar problemas de rendimiento. Se puede seleccionar cada fila de la cascada para abrir el panel de diagnóstico. En el caso de las solicitudes HTTP, verá un **traceId** que enlaza con la consola de Rastros.

  En el caso de las solicitudes HTTP con códigos de estado, bloqueos, ANR (Android) o bloqueos de aplicaciones (iOS) que no sean 2xx, el panel de diagnóstico incluye una pestaña **Excepción** con el rastro de la pila. El botón **Ver** de la cascada proporciona un acceso rápido a esta información.
+ La pestaña **Métricas** muestra todas las métricas predeterminadas de CloudWatch publicadas por el monitor de aplicaciones, lo que incluye las métricas de rendimiento (tiempos de carga de la pantalla, tiempos de lanzamiento de aplicaciones en frío), las métricas de error (bloqueos, ANR o bloqueos de aplicaciones, fallos o errores HTTP) y las métricas de volumen y apdex. Si ha creado métricas ampliadas para la aplicación, la pestaña también incluye un subconjunto de estas métricas en la sección de métricas ampliadas. Este subconjunto incluye métricas de los tipos ScreenLoadTime, ScreenLoadCount, CrashCount, Http4xxCount, Http5xxCount, ANRCount/AppHangCount, ColdLaunchTime y WarmLaunchTime. El panel muestra tres variaciones de métricas por tipo de métrica. Como se trata de métricas de CloudWatch, también puede exportar esta pestaña a su propio panel mediante la opción **Agregar al panel** y actualizarla para incluir más métricas.
+ La pestaña **Configuración** proporciona acceso a los detalles de configuración general y configuración del monitor de aplicaciones. También puede acceder a la pestaña **Fragmentos de código**, que contiene instrucciones para instrumentar la aplicación móvil con el SDK de ADOT, lo que incluye las opciones de instrumentación manual y de código cero.

### Cómo establece CloudWatch RUM las puntuaciones de Apdex
<a name="CloudWatch-RUM-apdex"></a>

Apdex (Application Performance Index) es un estándar abierto que define un método para informar, comparar y evaluar el tiempo de respuesta de las aplicaciones. Una puntuación de Apdex lo ayudará a comprender e identificar el impacto en el rendimiento de las aplicaciones a lo largo del tiempo.

La puntuación de Apdex indica el nivel de satisfacción de los usuarios finales. Las puntuaciones oscilan entre 0 (menos satisfechos) y 1 (más satisfechos). Las puntuaciones se basan únicamente en el rendimiento de la aplicación. No se les solicita a los usuarios que califiquen la aplicación.

Cada puntuación individual de Apdex corresponde a uno de los tres umbrales. De acuerdo con el umbral de Apdex y el tiempo de respuesta real de la aplicación, existen tres tipos de rendimiento, como se indica a continuación:
+ **Satisfecho**: el tiempo de respuesta real de la aplicación es inferior o igual al umbral de Apdex. En el caso de CloudWatch RUM, este umbral es de 2000 ms o menos.
+ **Tolerable**: el tiempo de respuesta real de la aplicación es superior al umbral de Apdex, pero inferior o igual a cuatro veces el umbral de Apdex. En CloudWatch RUM, este intervalo es de 2000 a 8000 ms.
+ **Frustrante**: el tiempo real de respuesta de la aplicación es superior a cuatro veces el umbral de Apdex. En CloudWatch RUM, este rango supera los 8000 ms.

La puntuación total de 0 a 1 de Apdex se calcula con la siguiente fórmula:

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

# Métricas de CloudWatch que puede recopilar con CloudWatch RUM
<a name="CloudWatch-RUM-metrics"></a>

En las tablas de esta sección, se muestran las métricas que se recopilen automáticamente con CloudWatch RUM de aplicaciones web, móviles o ambas. También puede ver estas métricas en la consola de CloudWatch. Para obtener más información, consulte [Ver métricas disponibles](viewing_metrics_with_cloudwatch.md).

De forma opcional, también puede enviar métricas ampliadas a CloudWatch. Para obtener más información, consulte [Métricas ampliadas](CloudWatch-RUM-custom-and-extended-metrics.md#CloudWatch-RUM-vended-metrics).

Estas métricas se publican en el espacio de nombres de la métrica llamado `AWS/RUM`. Todas las métricas siguientes se publican con una dimensión de `application_name`. El valor de esta dimensión es el nombre del supervisor de aplicaciones. Algunas métricas también se publican con dimensiones adicionales, como se indica en la siguiente tabla.


**Métricas web**  

| Métrica | Unidad | Descripción | 
| --- | --- | --- | 
|  `HttpStatusCodeCount` |  Recuento  |  El recuento de respuestas HTTP en la aplicación, según su código de estado de respuesta. Dimensiones adicionales: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `Http4xxCount` |  Recuento  |  El recuento de respuestas HTTP en la aplicación, según su código de estado de respuesta 4xx. Se calculan en función de los eventos de RUM `http_event` que dan como resultado códigos 4xx.  | 
|  `Http4xxCountPerSession` |  Recuento  |  El recuento de respuestas HTTP en una sesión, según su código de estado de respuesta 4xx. Se calculan en función de los eventos de RUM `http_event` que dan como resultado códigos 4xx.  | 
|  `Http4xxCountPerPageView` |  Recuento  |  El recuento de respuestas HTTP en una revisión de la página, según su código de estado de respuesta 4xx. Se calculan en función de los eventos de RUM `http_event` que dan como resultado códigos 4xx.  | 
|  `Http5xxCount` |  Recuento  |  El recuento de respuestas HTTP en la aplicación, según su código de estado de respuesta 5xx. Se calculan en función de los eventos de RUM `http_event` que dan como resultado códigos 5xx.  | 
|  `Http5xxCountPerSession` |  Recuento  |  El recuento de respuestas HTTP en la sesión, según su código de estado de respuesta 5xx. Se calculan en función de los eventos de RUM `http_event` que dan como resultado códigos 5xx.  | 
|  `Http5xxCountPerPageView` |  Recuento  |  El recuento de respuestas HTTP en una revisión de la página, según su código de estado de respuesta 5xx. Se calculan en función de los eventos de RUM `http_event` que dan como resultado códigos 5xx.  | 
|  `JsErrorCount` |  Recuento  |  El recuento de los eventos de error de JavaScript incorporados.   | 
|  `JsErrorCountPerSession` |  Recuento  |  El recuento de eventos de error de JavaScript ingeridos en una sesión.  | 
|  `JsErrorCountPerPageView` |  Recuento  |  El recuento de eventos de error de JavaScript ingeridos en una revisión de la página.  | 
|  `NavigationFrustratedTransaction` |  Recuento  |  El recuento de los eventos de navegación con una `duration` superior al límite frustrante, que es de 8000 ms. Se realiza un seguimiento de la duración de los eventos de navegación en la métrica `PerformanceNavigationDuration`.  | 
|  `NavigationSatisfiedTransaction` |  Recuento  |  El recuento de los eventos de navegación con una `duration` menor que el objetivo de Apdex, que es de 2000 ms. Se realiza un seguimiento de la duración de los eventos de navegación en la métrica `PerformanceNavigationDuration`.  | 
|  `NavigationToleratedTransaction` |  Recuento  |  El recuento de los eventos de navegación con una `duration` entre 2000 ms y 8000 ms. Se realiza un seguimiento de la duración de los eventos de navegación en la métrica `PerformanceNavigationDuration`.  | 
|  `PageViewCount` |  Recuento  |  El recuento de los eventos de visualización de páginas incorporados por el monitor de la aplicación. Esto se calcula contando los eventos de RUM `page_view_event`.  | 
|  `PageViewCountPerSession` |  Recuento  |  El recuento de eventos de visualización de páginas en una sesión. | 
|  `PerformanceResourceDuration` |  Milisegundos  |  La `duration` de un evento de recursos. Dimensiones adicionales: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `PerformanceNavigationDuration` |  Milisegundos  |  La `duration` de un evento de navegación.  | 
|  `RumEventPayloadSize` |  Bytes  |  El tamaño de cada evento incorporado por CloudWatch RUM. También puede utilizar la estadística `SampleCount` de esta métrica para controlar la cantidad de eventos que incorpora un supervisor de aplicaciones.  | 
|  `SessionCount` |  Recuento  |  El recuento de los eventos de inicio de sesión incorporados por el supervisor de aplicaciones. Es decir, la cantidad de nuevas sesiones iniciadas.  | 
|  `SessionDuration` |  Milisegundos  |  La duración de una sesión. Se calculan en función del tiempo transcurrido entre el primer y el último evento de una sesión.  | 
|  `TimeOnPage` |  Milisegundos  |  La duración de la visualización de una página. Se calculan en función del tiempo que transcurre hasta la siguiente visualización de una página, excepto en el caso de la última página de la sesión, en la que se calcula el tiempo transcurrido entre el primer y el último evento de esa página.  | 
|  `WebVitalsCumulativeLayoutShift` |  Ninguno  |  Realiza un seguimiento del valor de los eventos de cambio de diseño acumulativos.  | 
|  `WebVitalsFirstInputDelay` |  Milisegundos  |  Realiza un seguimiento del valor de los primeros eventos de retardo de entradas.  | 
|  `WebVitalsLargestContentfulPaint` |  Milisegundos  |  Realiza un seguimiento del valor de los eventos de pintura con contenido más grandes.  | 
|  `WebVitalsInteractionToNextPaint` |  Milisegundos  |  Realiza un seguimiento del valor de la interacción hasta los siguientes eventos de pintura.  | 

Puede configurar métricas ampliadas para la aplicación móvil a fin de proporcionar dimensiones adicionales para el análisis.


**Métricas móviles**  

| Métrica | Unidad | Descripción | 
| --- | --- | --- | 
|  `ANRCount`  |  Recuento  |  Solo para Android: el número de incidentes de aplicaciones que no responden (ANR), que se producen cuando la aplicación no responde durante más de 5 segundos y provocan un bloqueo de la aplicación.  | 
|  `AppHangCount`  |  Recuento  |  Solo para iOS: el número de veces que la aplicación dejó de responder durante más de 250 ms en el bucle principal.  | 
|  `ColdAppLaunchFrustratedTransaction`  |  Recuento  |  Número de lanzamientos de aplicaciones en frío que tardaron más de 8 segundos en completarse, lo que probablemente provoque frustración a los usuarios.  | 
|  `ColdAppLaunchSatisfiedTransaction`  |  Recuento  |  Número de lanzamientos de aplicaciones en frío que se completaron en menos de 2 segundos, lo que proporcionó una experiencia de usuario satisfactoria.  | 
|  `ColdAppLaunchToleratedTransaction`  |  Recuento  |  Número de lanzamientos de aplicaciones en frío que se completaron entre 2 y 8 segundos, lo que proporciona una experiencia de usuario tolerable, pero no ideal.  | 
|  `ColdLaunchTime`  |  Milisegundos  |  Tiempo necesario para lanzar la aplicación desde un estado terminado. Para Android: tiempo desde `onCreate` de la aplicación hasta que se termina de crear la primera actividad. Para iOS: tiempo desde el inicio de la aplicación (determinado por el comando de inicio del proceso `sysctl`) hasta `didBecomeActiveNotification`.  | 
|  `CrashCount`  |  Recuento  |  Número de terminaciones inesperadas de aplicaciones provocadas por excepciones no controladas o por la terminación del sistema operativo. Para Android: bloqueos debidos a excepciones no controladas o la terminación del sistema. Para iOS: bloqueos debidos a excepciones no controladas, errores fatales o la terminación del sistema. Los datos de los bloqueos se almacenan localmente y se notifican la próxima vez que se lance la aplicación.  | 
|  `DroppedEventsCount`  |  Recuento  |  Número de eventos de registro que se eliminaron porque superaron el límite de tamaño máximo de 30 KB por evento.  | 
|  `DroppedSpansCount`  |  Recuento  |  Número de intervalos que se eliminaron porque superaron el límite de tamaño máximo de 30 KB por intervalo.  | 
|  `Http4xxCount`  |  Recuento  |  Registra el número de errores del cliente HTTP detectados por la aplicación web o móvil durante las solicitudes HTTP.  | 
|  `Http5xxCount`  |  Recuento  |  Registra el número de errores del servidor HTTP detectados por la aplicación web o móvil durante las solicitudes HTTP.  | 
|  `LogPayloadSize`  |  Bytes  |  Tamaño en bytes de los datos de telemetría del registro que se envían a CloudWatch RUM. También puede utilizar la estadística `SampleCount` de esta métrica para supervisar la cantidad de eventos de registros que ingiere un monitor de aplicaciones.  | 
|  `NetworkLatency`  |  Milisegundos  |  Tiempo que tardan en completarse las solicitudes de red, que mide el tiempo de ida y vuelta desde el inicio de la solicitud hasta la finalización de la respuesta.  | 
|  `ScreenLoadCount`  |  Recuento  |  Número total de cargas de pantalla.  | 
|  `ScreenLoadToleratedTransaction`  |  Recuento  |  Número de cargas de pantalla que se completaron entre 2 y 8 segundos, lo que proporciona una experiencia de usuario tolerable, pero no ideal.  | 
|  `SessionCount`  |  Recuento  |  Número total de sesiones de usuarios únicos de la aplicación. Una sesión comienza cuando el usuario abre la aplicación y finaliza después de 30 minutos de inactividad o cuando se termina explícitamente.  | 
|  `SpanPayloadSize`  |  Bytes  |  Tamaño en bytes de los datos de telemetría del intervalo que se envían a CloudWatch RUM. También puede utilizar la estadística `SampleCount` de esta métrica para supervisar la cantidad de intervalos de registros que ingiere un monitor de aplicaciones.  | 
|  `WarmAppLaunchFrustratedTransaction`  |  Recuento  |  Número de lanzamientos de aplicaciones en caliente que tardaron más de 8 segundos en completarse, lo que probablemente provoque frustración a los usuarios.  | 
|  `WarmAppLaunchSatisfiedTransaction`  |  Recuento  |  Número de lanzamientos de aplicaciones en caliente que se completaron en menos de 2 segundos, lo que proporcionó una experiencia de usuario satisfactoria.  | 
|  `WarmAppLaunchToleratedTransaction`  |  Recuento  |  Número de lanzamientos de aplicaciones en caliente que se completaron entre 2 y 8 segundos, lo que proporciona una experiencia de usuario tolerable, pero no ideal.  | 
|  `WarmLaunchTime`  |  Milisegundos  |  Tiempo necesario para lanzar la aplicación desde un estado en segundo plano. Para Android: tiempo desde `onCreate` de la aplicación hasta que se termina de crear la primera actividad. Para iOS: tiempo desde `UIApplicationWillEnterForegroundNotification` hasta `didBecomeActiveNotification`.  | 

# Métricas personalizadas y ampliadas que puede enviar a CloudWatch
<a name="CloudWatch-RUM-custom-and-extended-metrics"></a>

De forma predeterminada, los monitores de aplicaciones de RUM envían métricas a CloudWatch. Estas métricas y dimensiones predeterminadas se muestran en [Métricas de CloudWatch que puede recopilar con CloudWatch RUM](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html).

También puede configurar un monitor de aplicaciones para que exporte métricas. El monitor de aplicaciones puede enviar métricas ampliadas, métricas personalizadas o ambas. Puede enviarlas a CloudWatch.
+ **Métricas personalizadas**: las métricas personalizadas son métricas que el usuario define. Con las métricas personalizadas, puede usar cualquier nombre y espacio de nombres de métrica. Para derivar las métricas, puedes usar cualquier evento personalizado, evento integrado, atributo personalizado o atributo predeterminado.

  Puede enviar métricas personalizadas a CloudWatch.
+ **Métricas ampliadas**: puede enviar cualquiera de las métricas de CloudWatch RUM predeterminadas a CloudWatch con dimensiones adicionales. De este modo, estas métricas pueden ofrecerle una visión más detallada.

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

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

Para enviar métricas personalizadas, debe utilizar las API de AWS o AWS CLI en lugar de la consola. Para obtener más información sobre el uso de las API de AWS, consulte [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html) y [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

Un destino puede contener un máximo de 2000 definiciones de métricas ampliadas y personalizadas. Para cada métrica personalizada o ampliada que envíe a cada destino, cada combinación de nombre y valor de dimensión cuenta para este límite. No se le cobrarán las métricas personalizadas derivadas de ningún tipo de evento o atributo de CloudWatch RUM.

El siguiente ejemplo muestra cómo crear una métrica personalizada derivada de un evento personalizado. Este es el ejemplo de evento personalizado que se utiliza:

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

Dado este evento personalizado, puede crear una métrica personalizada que cuente el número de visitas a la URL `amazonaws.com` desde navegadores Chrome. La siguiente definición crea una métrica denominada `AmazonVisitsCount` en su cuenta, en el espacio de nombres `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 ampliadas
<a name="CloudWatch-RUM-vended-metrics"></a>

Si configura las métricas ampliadas, puede enviar cualquiera de las métricas predeterminadas de CloudWatch RUM a CloudWatch con dimensiones adicionales para que las métricas le ofrezcan una visión más detallada.

Para obtener más información acerca de las métricas de CloudWatch RUM, consulte [Métricas de CloudWatch que puede recopilar con CloudWatch RUM](CloudWatch-RUM-metrics.md).

Un destino puede contener un máximo de 2000 definiciones de métricas ampliadas y personalizadas. Para cada métrica extendida que envíe a cada destino, cada combinación de nombre y valor de dimensión cuenta como una métrica extendida para este límite.

Al enviar métricas ampliadas a CloudWatch, puede utilizar la consola de CloudWatch RUM para crear alarmas de CloudWatch en ellas.

No se le cobrarán las métricas ampliadas que se creen para las métricas predeterminadas de CloudWatch RUM.

### Métricas ampliadas de aplicaciones web
<a name="CloudWatch-RUM-web-extended-metrics"></a>

Las siguientes dimensiones son compatibles con las métricas ampliadas de aplicaciones web:
+ `BrowserName`

  Ejemplos de valores de dimensión: `Chrome`, `Firefox`, `Chrome Headless`
+ `CountryCode`: utiliza el formato ISO-3166, con códigos de dos letras.

  Ejemplos de valores de dimensión: `US`, `JP`, `DE`
+ `DeviceType`

  Ejemplos de valores de dimensión: `desktop`, `mobile`, `tablet`, `embedded`
+ `FileType`

  Ejemplos de valores de dimensión: `Image`, `Stylesheet`
+ `OSName`

  Ejemplos de valores de dimensión: `Linux`, `Windows`, `iOS`, `Android`
+ `PageId`

### Métricas ampliadas de aplicaciones móviles
<a name="CloudWatch-RUM-mobile-extended-metrics"></a>

Las siguientes dimensiones son compatibles con las métricas ampliadas de aplicaciones móviles:
+ `ScreenName`
  + Valor del atributo del nombre de pantalla: `attributes.screen.name` de la aplicación
  + Valores de ejemplo: HomeScreen, SettingsView, ProfilePage
+ `DeviceModel`
  + Valor del atributo del modelo del dispositivo: `resource.attributes.device.model.name`
  + Valores de ejemplo: iPhone14.3, SM-G998B
+ `OSVersion`
  + Valor del atributo de la versión del sistema operativo: `resource.attributes.os.version`
  + Valores de ejemplo: 16.0, 13.0

**nota**  
Métricas predeterminadas compatibles actualmente con las aplicaciones móviles: `ScreenLoadTime`, `ScreenLoadCount`, `NetworkLatency`, `Http4xxCount`, `Http5xxCount`, `CrashCount`, `ANRCount`, `AppHangCount`, `ColdLaunchTime`, `WarmLaunchTime`, `SessionCount`, `SpanPayloadSize` y `LogPayloadSize`.

### Configuración de métricas ampliadas con la consola
<a name="CloudWatch-RUM-extended-metrics-console"></a>

Para usar la consola para enviar métricas ampliadas a CloudWatch, siga estos pasos.

Para obtener información sobre el uso de las API de AWS para enviar métricas ampliadas a CloudWatch, consulte [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html) y [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

**Usar la consola para configurar un monitor de aplicaciones y enviar las métricas ampliadas de RUM a CloudWatch**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija el nombre del monitor de aplicaciones que enviará las métricas.

1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **RUM extended metrics** (Métricas ampliadas de RUM).

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

1. Seleccione uno o más nombres de métricas para enviarlos con dimensiones adicionales.

1. Seleccione uno o más factores para utilizarlos como dimensiones para estas métricas. Al hacer sus elecciones, la cantidad de métricas ampliadas que crean sus elecciones se muestra en **Number of extended metrics** (Número de métricas ampliadas).

   Este número se calcula multiplicando el número de nombres de métricas elegidos por el número de dimensiones diferentes que se crean.

   1. Para enviar una métrica con el ID de página como dimensión, elija **Browse for page ID** (Buscar el ID de página) y, a continuación, seleccione los ID de página que desee utilizar.

   1. Para enviar una métrica con el tipo de dispositivo como dimensión, elija **Desktop devices** (Dispositivos de escritorio) o **Mobile and tablets** (Móviles y tabletas).

   1. Para enviar una métrica con el sistema operativo como dimensión, seleccione uno o más sistemas operativos en **Operating system** (Sistema operativo).

   1. Para enviar una métrica con el tipo de navegador como dimensión, seleccione uno o más navegadores en **Browsers** (Navegadores).

   1. Para enviar una métrica con la ubicación geográfica como dimensión, seleccione una o más ubicaciones en **Locations** (Ubicaciones).

      Solo aparecerán en la lista para elegir las ubicaciones desde las que este monitor de aplicaciones haya informado sobre métricas.

1. Cuando haya terminado con las opciones, elija **Send metrics** (Enviar métricas).

1. (Opcional) En la lista **Extended metrics** (Métricas ampliadas), para crear una alarma que controle una de las métricas, elija **Create alarm** (Crear alarma) en la fila de esa métrica.

   Para obtener información general sobre las alarmas de CloudWatch, consulte [Uso de las alarmas de Amazon CloudWatch](CloudWatch_Alarms.md). Para ver un tutorial sobre cómo configurar una alarma en una métrica ampliada de CloudWatch RUM, consulte [Tutorial: crear una métrica ampliada y ponerle una alarma](#CloudWatch-RUM-extended-metrics-alarmtutorial).

**Dejar de enviar métricas ampliadas**

**Usar la consola para dejar de enviar métricas ampliadas**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija el nombre del monitor de aplicaciones que enviará las métricas.

1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **RUM extended metrics** (Métricas ampliadas de RUM).

1. Seleccione una o más combinaciones de nombre y dimensión de métrica para detener el envío. A continuación, elija **Actions** (Acciones), **Delete** (Eliminar).

### Tutorial: crear una métrica ampliada y ponerle una alarma
<a name="CloudWatch-RUM-extended-metrics-alarmtutorial"></a>

Este tutorial muestra cómo configurar una métrica ampliada para enviarla a CloudWatch y, a continuación, cómo configurar una alarma en esa métrica. En este tutorial, creará una métrica que realice un seguimiento de los errores de JavaScript en el navegador Chrome.

**Configuración de esta métrica ampliada y cómo establecer una alarma**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija el nombre del monitor de aplicaciones que enviará la métrica.

1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **RUM extended metrics** (Métricas ampliadas de RUM).

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

1. Seleccione **JSErrorCount**.

1. En **Browsers** (Navegadores), seleccione **Chrome**.

   Esta combinación de **JSErrorCount** y **Chrome** enviará una métrica ampliada a CloudWatch. La métrica solo cuenta los errores de JavaScript en las sesiones de usuario que utilicen el navegador Chrome. El nombre de la métrica será **JSErrorCount** y el nombre de la dimensión será **Browser** (Navegador).

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

1. En la lista **Extended metrics** (Métricas ampliadas), seleccione **Create alarm** (Crear alarma) en la fila que muestre **JSErrorCount** en **Name** (Nombre) y **Chrome** en **BrowserName** (Nombre del navegador).

1. En **Specify metric and conditions** (Especificar métrica y condiciones), confirme que los campos **Metric name** (Nombre de la métrica) y **BrowserName** estén rellenados previamente con los valores correctos.

1. En **Statistic** (Estadística), seleccione la estadística que desee utilizar para la alarma. **Average** (Promedio) es una buena opción para este tipo de métrica de recuento.

1. En **Period (Período)**, seleccione **5 minutes (5 minutos)**.

1. En **Condiciones**, haga lo siguiente:
   + Elija **Static** (Estático).
   + Elija **Greater** (Mayor) para especificar que la alarma debe pasar al estado ALARM (ALARMA) cuando el número de errores sea superior al umbral que esté a punto de especificar.
   + En **than…** (que…), ingrese el número del umbral de la alarma. La alarma entra en estado ALARM cuando el número de errores en un período de 5 minutos supera este número.

1. (Opcional) De forma predeterminada, la alarma pasa al estado ALARM en cuanto el número de errores supera el umbral establecido durante un período de 5 minutos. Si lo desea, puede cambiarlo para que la alarma entre en estado ALARM solo si se supera este número durante más de un período de 5 minutos.

   Para ello, seleccione **Additional configuration** (Configuración adicional) y, a continuación, en **Datapoints to alarm** (Puntos de datos para la alarma), especifique cuántos períodos de 5 minutos deben tener el número de errores por encima del umbral para activar la alarma. Por ejemplo, puede seleccionar 2 de 2 para que la alarma se active solo cuando dos períodos consecutivos de 5 minutos superen el umbral, o 2 de 3 para que se active la alarma si 2 de los 3 períodos consecutivos de 5 minutos superan el umbral. 

   Para obtener más información acerca de este tipo de evaluación de alarmas, consulte [Evaluación de alarmas](alarm-evaluation.md).

1. Elija **Siguiente**.

1. En **Configure actions** (Configurar acciones), especifique lo que debe suceder cuando la alarma entre en estado de alarma. Para recibir una notificación con Amazon SNS, haga lo siguiente:
   + Seleccione **Agregar notificación**.
   + Elija **En alarma**.
   + Seleccione un tema de SNS existente o cree uno nuevo. Si crea uno nuevo, especifique un nombre y agregue al menos una dirección de correo electrónico.

1. Elija **Siguiente**.

1. Ingrese un nombre y, si lo desea, una descripción de la alarma y elija **Next** (Siguiente).

1. Revise los detalles y seleccione **Crear alarma**.

# Protección de datos y privacidad de datos con CloudWatch RUM
<a name="CloudWatch-RUM-privacy"></a>

El [modelo de responsabilidad compartida](https://aws.amazon.com/compliance/shared-responsibility-model/) de AWS se aplica a la protección y la privacidad de datos en Amazon CloudWatch RUM. Tal como se describe en este modelo, AWS es responsable de proteger la infraestructura global que ejecuta toda la nube de AWS. Eres responsable de mantener el control sobre el contenido alojado en esta infraestructura. Para obtener más información sobre la privacidad de datos, consulte [Data Privacy FAQ](https://aws.amazon.com/compliance/data-privacy-faq/) (Preguntas frecuentes sobre la privacidad de datos). Para obtener información sobre la protección de datos en Europa, consulte la publicación de blog [The AWS Shared Responsibility Model and GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) (Modelo de responsabilidad compartida y RGPD) en el AWS Security Blog. Para obtener más recursos sobre el cumplimiento de los requisitos del RGPD, consulte el [Centro de reglamento general de protección de datos (RGPD)](https://aws.amazon.com/compliance/gdpr-center/).

Amazon CloudWatch RUM genera un fragmento de código para que lo incruste en el código de su sitio web o aplicación web, en función de la entrada de datos de usuario final que desea recopilar. El cliente web, descargado y configurado mediante el fragmento de código, utiliza cookies (o tecnologías similares) para recopilar datos del usuario final. El uso de cookies (o tecnologías similares) está sujeto a las normas de privacidad de datos en determinadas jurisdicciones. Antes de utilizar Amazon CloudWatch RUM, le recomendamos ampliamente que evalúe sus obligaciones de cumplimiento conforme a la legislación aplicable, incluidos los requisitos legales aplicables para proporcionar avisos de privacidad legalmente adecuados y obtener el consentimiento necesario para el uso de cookies y el procesamiento (incluida la recopilación) de datos del usuario final. Para obtener más información sobre la forma en la que el cliente web utiliza las cookies (o tecnologías similares) y qué datos de usuario final recopila, consulte [Información recopilada por el cliente web de CloudWatch RUM](CloudWatch-RUM-datacollected.md) y [Cookies del cliente web de CloudWatch RUM (o tecnologías similares)](#CloudWatch-RUM-cookies).

Le recomendamos que nunca ingrese información confidencial que lo identifique, como números de cuenta de los usuarios finales, correos electrónicos u otro tipo de información personal, en los campos de formato libre. Cualquier dato que ingrese en Amazon CloudWatch RUM o en otros servicios se puede incluir en los registros de diagnóstico. 



## Cookies del cliente web de CloudWatch RUM (o tecnologías similares)
<a name="CloudWatch-RUM-cookies"></a>

El cliente web de CloudWatch RUM recopila determinados datos sobre las sesiones de usuario de forma predeterminada. Puede optar por habilitar las cookies para que el cliente web también recopile un ID de usuario y un ID de sesión cada vez que se carga la página. El ID de usuario se genera de forma aleatoria mediante RUM.

Si estas cookies están habilitadas, RUM podrá mostrar los siguientes tipos de datos cuando usted vea el panel de RUM de este monitor de aplicaciones.
+ Datos agregados basados en ID de usuario, como el número de usuarios únicos y el número de usuarios diferentes que han experimentado un error. 
+ Datos agregados basados en ID de sesión, como el número de sesiones y el número de sesiones que han experimentado un error. 
+ El *user journey* (recorrido del usuario), que es la secuencia de páginas que incluye cada sesión de usuario de muestra. 

**importante**  
Si no habilita estas cookies (o tecnologías similares), el cliente web seguirá registrando cierta información sobre las sesiones del usuario final, como el tipo/versión del navegador, el tipo/versión del sistema operativo, el tipo de dispositivo, entre otros. Se recopilan para proporcionar información agregada específica de la página, como web vitals, vistas de página y páginas que han experimentado errores. Para obtener más información acerca de los datos registrados, consulte [Información recopilada por el cliente web de CloudWatch RUM](CloudWatch-RUM-datacollected.md).

# Información recopilada por el cliente web de CloudWatch RUM
<a name="CloudWatch-RUM-datacollected"></a>

En esta sección se documenta el esquema de **PutRumEvents**, que define la estructura de los datos que puede recopilar de las sesiones de usuario mediante CloudWatch RUM.

Una solicitud de **PutRumEvents** envía una estructura de datos con los siguientes campos a CloudWatch RUM.
+ El ID de este lote de eventos RUM
+ Detalles del monitor de aplicaciones, que incluye lo siguiente:
  + ID del monitor de aplicaciones
  + versión de la aplicación supervisada
+ Datos del usuario, que incluye lo siguiente.** Esto se recopila solo si el monitor de aplicaciones tiene las cookies habilitadas.**
  + ID de usuario generado por el cliente web
  + ID de sesión
+ La matriz de [eventos de RUM](#CloudWatch-RUM-datacollected-event) en este lote.

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

La estructura de cada evento de RUM incluye los siguientes campos.
+ El ID del evento
+ Una marca temporal
+ El tipo de evento
+ El agente de usuario
+ [Metadatos](#CloudWatch-RUM-datacollected-metadata)
+ [Detalles del evento de RUM](#CloudWatch-RUM-datacollected-eventDetails)

## Metadatos del evento de RUM
<a name="CloudWatch-RUM-datacollected-metadata"></a>

Los metadatos incluyen metadatos de página, metadatos de agente de usuario, metadatos de geolocalización y metadatos de dominio.

### Metadatos de la página
<a name="CloudWatch-RUM-datacollected-metadata-page"></a>

Los metadatos de la página incluyen lo siguiente:
+ ID de página
+ Título de página
+ ID de página principal. – **Esto se recopila solo si el monitor de aplicaciones tiene las cookies habilitadas.**
+ Profundidad de interacción: **se recopila solo si el monitor de aplicaciones tiene las cookies habilitadas.**
+ Etiquetas de página: puede añadir etiquetas a los eventos de la página para agrupar las páginas. Para obtener más información, consulte [Uso de grupos de páginas](CloudWatch-RUM-page-groups.md).

### Metadatos del agente de usuario
<a name="CloudWatch-RUM-datacollected-metadata-useragent"></a>

Los metadatos del agente de usuario incluyen lo siguiente:
+ Idioma del navegador
+ Nombre del navegador
+ Versión del navegador
+ Nombre del sistema operativo
+ Versión del sistema operativo
+ Tipo de dispositivo
+ Tipos de plataformas

### Metadatos de geolocalización
<a name="CloudWatch-RUM-datacollected-metadata-geolocation"></a>

Los metadatos de geolocalización incluyen lo siguiente:
+ Código de país
+ Código de subdivisión

### Metadatos del dominio
<a name="CloudWatch-RUM-datacollected-metadata-domain"></a>

Los metadatos del dominio incluyen el dominio URL.

## Detalles del evento de RUM
<a name="CloudWatch-RUM-datacollected-eventDetails"></a>

Los detalles de un evento cumplen con uno de los siguientes tipos de esquemas, según el tipo de evento.

### Evento de inicio de sesión
<a name="CloudWatch-RUM-datacollected-sessionstart"></a>

Este evento no contiene campos. **Esto se recopila solo si el monitor de aplicaciones tiene las cookies habilitadas.**

### Esquema de vista de página
<a name="CloudWatch-RUM-datacollected-pageview"></a>

Un evento de **Vista de página** contiene las siguientes propiedades. Puede desactivar la colección de vistas de página si configura el cliente web. Para obtener más información, consulte la [documentación del cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nombre | Tipo | Descripción | 
| --- | --- | --- | 
|  **ID de página** |  Cadena  |  ID que representa de forma exclusiva esta página dentro de la aplicación. De forma predeterminada, esta es la ruta URL.  | 
|  **ID de la página principal** |  Cadena  |  Id. de la página en la que se encontraba el usuario cuando navegó a la página actual. **Esto se recopila solo si el monitor de aplicaciones tiene las cookies habilitadas.**   | 
|  **Profundidad de interacción** |  Cadena  |  **Esto se recopila solo si el monitor de aplicaciones tiene las cookies habilitadas.**   | 

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

Los eventos de error de JavaScript generados por el agente contienen las siguientes propiedades. El cliente web recopila estos eventos solo si ha seleccionado recopilar los errores de telemetría.


| Nombre | Tipo | Descripción | 
| --- | --- | --- | 
|  **Tipo de error** |  Cadena  |  El nombre del error, si existe alguno. Para obtener más información, consulte [Error.prototype.name](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name). Es posible que algunos navegadores no admitan tipos de errores.  | 
|  **Mensaje de error** |  Cadena  |  Mensaje de error. Para obtener más información, consulte [Error.prototype.message](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message). Si el campo de error no existe, este es el mensaje del evento de error. Para obtener más información, consulte [ErrorEvent](https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent).  Es posible que los mensajes de error no sean coherentes según los distintos navegadores.  | 
|  **Seguimiento de pila** |  Cadena  |  El seguimiento de pila del error, si existe, se trunca a 150 caracteres. Para obtener más información, consulte [Error.prototype.stack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack).  Es posible que algunos navegadores no admitan seguimientos de pila.  | 

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

Los eventos del modelo de objeto de documento (DOM) generados por el agente contienen las siguientes propiedades. Estos eventos no se recopilan de forma predeterminada. Solo se recopilan si activa la telemetría de interacciones. Para obtener más información, consulte la [documentación del cliente web de CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nombre | Tipo | Descripción | 
| --- | --- | --- | 
|  **Evento** |  Cadena  |  El tipo de evento DOM, como hacer clic, deslizar o desplazar el ratón. Para obtener más información, consulte [Event reference](https://developer.mozilla.org/en-US/docs/Web/Events) (Referencia de eventos).  | 
|  **Elemento** |  Cadena  |  El tipo de elemento DOM  | 
|  **ID del elemento** |  Cadena  |  Si el elemento que generó el evento tiene un ID, esta propiedad almacena ese ID. Para obtener más información, consulte [Element.id](https://developer.mozilla.org/en-US/docs/Web/API/Element/id).  | 
|  **Localizador CSS** |  Cadena  |  El localizador CSS utilizado para identificar el elemento DOM.  | 
|  **ID de interacción** |  Cadena  |  Un identificador único para la interacción entre el usuario y la interfaz de usuario.  | 

### Esquema de eventos de navegación
<a name="CloudWatch-RUM-datacollected-NavigationEvent"></a>

Los eventos de navegación se recopilan solo si el monitor de la aplicación tiene activada la telemetría de rendimiento.

Los eventos de navegación utilizan API de [Navigation timing Level 1](https://www.w3.org/TR/navigation-timing/#performancetiming) (Temporización de navegación Nivel 1) y [Navigation timing Level 2](https://w3c.github.io/navigation-timing) (Temporización de navegación Nivel 2). Las API de nivel 2 no son compatibles con todos los navegadores, por lo que estos campos más recientes son opcionales.

**nota**  
Las métricas de marca temporal se basan en [DOMHighResTimestamp](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp). Con las API de nivel 2, todas las temporizaciones están relacionadas a de forma predeterminada `startTime`. Sin embargo, para el nivel 1, la métrica `navigationStart` se descuenta de las métricas de marca temporal para obtener valores relativos. Todos los valores de marca temporal se expresan en milisegundos.

Los eventos de navegación contienen las siguientes propiedades.


| Nombre | Tipo | Descripción | Notas | 
| --- | --- | --- | --- | 
|  **initiatorType** |  Cadena  |  Representa el tipo de recurso que inició el evento de rendimiento.  |  **Valor:** “navegación” **Nivel 1:** “navegación” **Nivel 2:** entryData.initiatorType | 
|  **navigationType** |  Cadena  |  Representa el tipo de navegación. Este atributo no es obligatorio. |  **Valor**: este valor tiene que ser uno de los siguientes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html) | 
|  **startTime** |  Número  |  Indica cuándo se desencadena el evento.  |  **Valor:** 0 **Nivel 1:** entryData.navigationStart - entryData.navigationStart  **Nivel 2:** entryData.startTime | 
|  **unloadEventStart** |  Número  |  Indica la hora en la que el documento previo de la ventana comenzó a descargarse tras el lanzamiento del evento de `unload` (descarga).  |  **Valor**: si no hay un documento previo o si el documento previo o uno de los redireccionamientos necesarios no son del mismo origen, el valor devuelto será 0. **Nivel 1:** <pre>entryData.unloadEventStart > 0<br />  ? entryData.unloadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Nivel 2:** entryData.unloadEventStart | 
|  **promptForUnload** |  Número  |  El tiempo que tarda en descargar el documento. En otras palabras, el tiempo entre `unloadEventStart` y `unloadEventEnd`. `UnloadEventEnd` representa el momento en milisegundos en el que el controlador de eventos de descarga finaliza.  |  **Valor**: si no hay un documento previo o si el documento previo o uno de los redireccionamientos necesarios no son del mismo origen, el valor devuelto será 0. **Nivel 1:** entryData.unloadEventEnd - entryData.unloadEventStart **Nivel 2:** entryData.unloadEventEnd - entryData.unloadEventStart | 
|  **redirectCount** |  Número  |  Número que representa la cantidad de redirecciones desde la última navegación sin redirección en el contexto de búsqueda actual.  Este atributo no es obligatorio. |  **Valor**: si no hay redirección o si hay alguna redirección que no sea del mismo origen que el documento de destino, el valor devuelto será 0. **Nivel 1:** no disponible **Nivel 2:** entryData.redirectCount | 
|  **redirectStart** |  Número  |  El momento en que se inicia la primera redirección HTTP.   |  **Valor**: si no hay redirección o si hay alguna redirección que no sea del mismo origen que el documento de destino, el valor devuelto será 0. **Nivel 1:** <pre>entryData.redirectStart > 0<br />  ? entryData.redirectStart - entryData.navigationStart<br />  : 0</pre> **Nivel 2:** entryData.redirectStart | 
|  **redirectTime** |  Número  |  El tiempo que tarda la redirección HTTP. Esta es la diferencia entre `redirectStart` y `redirectEnd`.   |  **Nivel 1:** entryData.redirectEnd - entryData.redirectStart **Nivel 2:** entryData.redirectEnd - entryData.redirectStart | 
|  **workerStart** |  Número  |  Esta es una propiedad de la interfaz `PerformanceResourceTiming`. Marca el comienzo de la operación de subprocesos de trabajo. Este atributo no es obligatorio. |  **Valor**: si ya se está ejecutando un subproceso de Service Worker o inmediatamente antes de iniciar el subproceso de Service Worker, esta propiedad devuelve la hora inmediatamente antes de despachar `FetchEvent`. Devuelve 0 si un Service Worker no intercepta el recurso. **Nivel 1:** no disponible **Nivel 2:** entryData.workerStart | 
|  **workerTime** |  Número  |  Si un Service Worker intercepta el recurso,esto devuelve el tiempo necesario para la operación de subprocesos de trabajo. Este atributo no es obligatorio. |  **Nivel 1:** no disponible  **Nivel 2:** <pre>entryData.workerStart > 0<br />   ? entryData.fetchStart - entryData.workerStart<br />   : 0</pre>  | 
|  **fetchStart** |  Número  |  La hora en la que el navegador está listo para recuperar el documento mediante una solicitud HTTP. Esto es antes de comprobar la caché de cualquier aplicación. |  **Nivel 1:**  <pre>: entryData.fetchStart > 0<br />  ? entryData.fetchStart - entryData.navigationStart<br />  : 0</pre> **Nivel 2:** entrydata.fetchStart | 
|  **domainLookup** |  Número  |  Hora en la que se inicia la búsqueda de dominios. |  **Valor**: si se utiliza una conexión persistente o si la información se almacena en una caché o en un recurso local, el valor será el mismo que el de `fetchStart`. **Nivel 1:** <pre>entryData.domainLookupStart > 0<br />  ? entryData.domainLookupStart - entryData.navigationStart<br />  : 0</pre> **Nivel 2:** entryData.domainLookupStart | 
|  **DNS** |  Número  |  El tiempo necesario para la búsqueda de dominios. |  **Valor**: si los recursos y los registros DNS se almacenan en la caché, el valor esperado será 0. **Nivel 1:** entryData.domainLookupEnd - entryData.domainLookupStart **Nivel 2:** entryData.domainLookupEnd - entryData.domainLookupStart | 
|  **nextHopProtocol** |  Cadena  |  Cadena que representa el protocolo de red que se utiliza para obtener el recurso. Este atributo no es obligatorio. |  **Nivel 1:** no disponible **Nivel 2:** entryData.nextHopProtocol | 
|  **connectStart** |  Número  |  Tiempo inmediatamente antes de que el agente de usuario comience a establecer la conexión con el servidor para recuperar el documento. |  **Valor**: si se utiliza una conexión persistente RFC2616 o si el documento actual se recupera desde cachés de aplicaciones o recursos locales relevantes, este atributo devuelve el valor de `domainLookupEnd`. **Nivel 1:** <pre>entryData.connectStart > 0<br />  ? entryData.connectStart - entryData.navigationStart<br />  : 0</pre> **Nivel 2:** entryData.connectStart  | 
|  **connect** |  Número  |  Mide el tiempo necesario para establecer las conexiones de transporte o para realizar la autenticación SSL. También incluye el tiempo bloqueado que se tarda cuando hay demasiadas solicitudes simultáneas emitidas por el navegador.  |  **Nivel 1:** entryData.connectEnd - entryData.connectStart **Nivel 2:** entryData.connectEnd - entryData.connectStart | 
|  **secureConnectionStart** |  Número  |  Si el esquema de URL de la página actual es “https”, este atributo devuelve el tiempo inmediatamente antes de que el agente de usuario inicie el proceso de enlace para proteger la conexión actual. Si no se utiliza HTTPS, devuelve 0. Para obtener más información sobre los esquemas de URL, consulte.[URL representation](https://url.spec.whatwg.org/#concept-url-scheme) (Representación de URL).  |  **Fórmula:** entryData.secureConnectionStart | 
|  **tlsTime** |  Número  |  El tiempo que lleva completar un enlace SSL.  |  **Nivel 1:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre> **Nivel 2:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre>  | 
|  **requestStart** |  Número  |  Tiempo inmediatamente antes de que el agente de usuario comience a solicitar el recurso del servidor, de las memorias caché de aplicaciones pertinentes o de recursos locales.   | **Nivel 1:** <pre>: entryData.requestStart > 0<br />  ? entryData.requestStart - entryData.navigationStart<br />  : 0<br /></pre> **Nivel 2:** entryData.requestStart | 
|  **timeToFirstByte** |  Número  |  Tiempo que tarda en recibir el primer byte de información después de haber realizado una solicitud. Esta vez es relativa a la `startTime`.   | **Nivel 1:** entryData.responseStart - entryData.requestStart **Nivel 2:** entryData.responseStart - entryData.requestStart | 
|  **responseStart** |  Número  |  Hora inmediatamente después de que el analizador HTTP del agente de usuario recibe el primer byte de la respuesta de las memorias caché de aplicaciones pertinentes, de recursos locales o del servidor.   | **Nivel 1:** <pre>entryData.responseStart > 0<br />   ? entryData.responseStart - entryData.navigationStart<br />   : 0</pre> **Nivel 2:** entryData.responseStart   | 
|  **responseTime** |  Cadena  |  Tiempo que tarda en recibir una respuesta completa en forma de bytes de las memorias caché de aplicaciones pertinentes, de recursos locales o del servidor.   | **Nivel 1:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre> **Nivel 2:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre>  | 
|  **domInteractive** |  Número  |  El momento en el que el analizador finaliza su trabajo en el documento principal y se construye el DOM en HTML. En este momento, el `Document.readyState` cambia a “interactivo” y se genera el evento `readystatechange` correspondiente.  | **Nivel 1:** <pre>entryData.domInteractive > 0<br />  ? entryData.domInteractive - entryData.navigationStart<br />  : 0</pre> **Nivel 2:** entryData.domInteractive  | 
|  **domContentLoadedEventStart** |  Número  |  Representa el valor de tiempo igual al tiempo inmediatamente anterior a que el agente de usuario active el evento DOMContentLoaded en el documento actual. El evento DOMContentLoaded se activará cuando el documento HTML inicial se haya cargado y analizado por completo. En ese momento, el documento HTML principal habrá terminado de analizar, el navegador comenzará a construir el render tree y los subrecursos aún deberán cargarse. Esto no esperará a que finalicen de cargar las hojas de estilo, las imágenes y los submarcos.  | **Nivel 1:** <pre>entryData.domContentLoadedEventStart > 0<br />  ? entryData.domContentLoadedEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Nivel 2:** entryData.domContentLoadedEventStart  | 
|  **domContentLoaded** |  Número  |  Esta hora de inicio y fin de la construcción del render tree está marcada por `domContentLoadedEventStart` y `domContentLoadedEventEnd`. Permite que CloudWatch RUM realice un seguimiento de la ejecución. Esta propiedad es la diferencia entre `domContentLoadedStart` y `domContentLoadedEnd`. Durante este tiempo, DOM y CSSOM están listos. Esta propiedad espera la ejecución del script, excepto los scripts asíncronos y creados dinámicamente. Si los scripts dependen de hojas de estilo, también `domContentLoaded` espera a las hojas de estilo. No espera a las imágenes.   Los valores reales de `domContentLoadedStart` y `domContentLoadedEnd` se aproximan a `domContentLoaded` en el panel Red de Google Chrome. Indica el tiempo de construcción del render tree HTML DOM \$1 CSSOM desde el principio del proceso de carga de la página. En el caso de las métricas de navegación, el valor `domContentLoaded` representa la diferencia entre los valores inicial y final, que es el tiempo necesario para descargar los subrecursos y la construcción del render tree únicamente.    | **Nivel 2:** entryData.domContentLoadedEventEnd - entryData.domContentLoadedEventStart  **Nivel 2:** entryData.domContentLoadedEventEnd - entryData.domContentLoadedEventStart  | 
|  **domComplete** |  Número  |  La hora inmediatamente anterior a que el navegador establezca la disponibilidad del documento actual para que se complete. En este momento, se ha completado la carga de subrecursos, como las imágenes. Esto incluye el tiempo que tarda en descargar contenido bloqueado como CSS y JavaScript sincrónico. Esto se aproxima a `loadTime` en el panel de Red de Google Chrome.   | **Nivel 1:** <pre>entryData.domComplete > 0<br />  ? entryData.domComplete - entryData.navigationStart<br />  : 0<br /></pre> **Nivel 2:** entryData.domComplete  | 
|  **domProcessingTime** |  Número  |  Tiempo total entre la respuesta y el inicio del evento de carga.  | **Nivel 1:** entryData.loadEventStart - entryData.responseEnd **Nivel 2:** entryData.loadEventStart - entryData.responseEnd  | 
|  **loadEventStart** |  Número  |  La hora inmediatamente anterior a que se active el evento de `load` (carga) del documento actual.  |  **Nivel 1:** <pre>entryData.loadEventStart > 0<br />  ? entryData.loadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Nivel 2:** entryData.loadEventStart | 
|  **loadEventTime** |  Número  |  La diferencia entre `loadEventStart` y `loadEventEnd`. Durante este tiempo se activarán funciones o lógica adicionales que aguardan este evento de carga. |  **Nivel 1:** entryData.loadEventEnd - entryData.loadEventStart **Nivel 2:** entryData.loadEventEnd - entryData.loadEventStart | 
|  **Duración** |  Cadena  |  La duración es el tiempo total de carga de la página. Registra el tiempo de descarga de la página principal y todos sus subrecursos sincrónicos, así como el tiempo para renderizar la página. Los recursos asincrónicos, como los scripts, continúan descargándose más adelante. Esta es la diferencia entre el `loadEventEnd` y `startTime` propiedades.  | **Nivel 1:** entryData.loadEventEnd - entryData.navigationStart **Nivel 2:** entryData.duration | 
|  **headerSize** |  Número  |  Devuelve la diferencia entre `transferSize` y `encodedBodySize`. Este atributo no es obligatorio.  | **Nivel 1:** no disponible **Nivel 2:** entryData.transferSize - entryData.encodedBodySize **Nivel 2:** entryData.transferSize - entryData.encodedBodySize | 
|  **compressionRatio** |  Número  |  La proporción de `encodedBodySize` y `decodedBodySize`. El valor de `encodedBodySize` es el tamaño comprimido del recurso, sin incluir los encabezados HTTP. El valor de `decodedBodySize` es el tamaño descomprimido del recurso, sin incluir los encabezados HTTP. Este atributo no es obligatorio.  | **Nivel 1:**No disponible. **Nivel 2:**<pre>entryData.encodedBodySize > 0<br />  ? entryData.decodedBodySize / entryData.encodedBodySize<br />  : 0</pre>  | 
|  **navigationTimingLevel** |  Número  |  La versión de la API de temporización de navegación.  | **Valor**: 1 o 2  | 

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

Los eventos de recursos se recopilan solo si el monitor de aplicaciones tiene activada la telemetría de rendimiento.

Las métricas de marca temporal se basan en [The DOMHighResTimeStamp typedef](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp). Con las API de nivel 2, todas las temporizaciones son relativas a la de forma predeterminada `startTime`. Sin embargo, para las API de nivel 1, la métrica de `navigationStart` se resta de las métricas de marca temporal para obtener valores relativos. Todos los valores de marca temporal se expresan en milisegundos.

Los eventos de recursos que genera el agente contienen las siguientes propiedades.


| Nombre | Tipo | Descripción | Notas | 
| --- | --- | --- | --- | 
|  **targetUrl** |  Cadena  |  Devuelve la URL del recurso.  |  **Fórmula:** [entryData.name](http://entrydata.name/) | 
|  **initiatorType** |  Cadena  |  Representa el tipo de recurso que inició el evento de recurso de rendimiento.  |  **Valor:** “recurso” **Fórmula:** entryData.initiatorType | 
|  **Duración** |  Cadena  |  Devuelve la diferencia entre las propiedades de `responseEnd` y `startTime`.Este atributo no es obligatorio.  | **Fórmula:** entryData.duration | 
|  **transferSize** |  Número  |  Devuelve el tamaño (en octetos) del recurso recuperado, incluidos los campos de encabezado de respuesta y el cuerpo de la carga de la respuesta.Este atributo no es obligatorio.  | **Fórmula:** entryData.transferSize | 
|  **fileType** |  Cadena  |  Extensiones derivadas del patrón de URL de destino.  |   | 

### Esquema del evento Largest Contentful Paint
<a name="CloudWatch-RUM-datacollected-LargestPaintEvent"></a>

Los eventos Largest Contentful Paint incluyen las siguientes propiedades.

Estos eventos se recopilan solo si el monitor de aplicaciones tiene activada la telemetría de rendimiento.


| Nombre | Descripción | 
| --- | --- | 
|  **Valor** |  Para obtener más información, consulte [Web Vitals](https://web.dev/vitals/).  | 

### Primer evento de retardo de entrada
<a name="CloudWatch-RUM-datacollected-FirstInputDelayEvent"></a>

Los primeros eventos de retardo de entrada contienen las siguientes propiedades.

Estos eventos se recopilan solo si el monitor de aplicaciones tiene activada la telemetría de rendimiento.


| Nombre | Descripción | 
| --- | --- | 
|  **Valor** |  Para obtener más información, consulte [Web Vitals](https://web.dev/vitals/).  | 

### Evento de cambio de diseño acumulativo
<a name="CloudWatch-RUM-datacollected-CumulativeShift"></a>

Los eventos de cambio de diseño acumulativos contienen las siguientes propiedades.

Estos eventos se recopilan solo si el monitor de aplicaciones tiene activada la telemetría de rendimiento.


| Nombre | Descripción | 
| --- | --- | 
|  **Valor** |  Para obtener más información, consulte [Web Vitals](https://web.dev/vitals/).  | 

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

Los eventos HTTP pueden contener las siguientes propiedades. Contendrá un campo `Response` (respuesta) o `Error` (error), pero no ambos.

Estos eventos se recopilan solo si el monitor de aplicaciones tiene activada la telemetría HTTP.


| Nombre | Descripción | 
| --- | --- | 
|  **Solicitud** |  La solicitud incluye lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Respuesta** |  La respuesta incluye lo que se detalla a continuación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Error** |  El campo de error incluye lo que se detalla a continuación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 

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

Estos eventos se recopilan solo si el monitor de la aplicación tiene activado el seguimiento de X-Ray.

Para obtener información sobre esquemas de eventos de seguimiento de X-Ray, consulte [Documentos de segmentos de AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-api-segmentdocuments.html).

# Tiempo de cambio de ruta para aplicaciones de una sola página
<a name="CloudWatch-RUM-route-change-timing"></a>

En una aplicación tradicional de varias páginas, cuando un usuario solicita que se cargue contenido nuevo, en realidad está solicitando una nueva página HTML al servidor. Como resultado, el cliente web CloudWatch RUM captura los tiempos de carga mediante las métricas de API de desempeño habituales.

Sin embargo, las aplicaciones web de una sola página utilizan JavaScript y Ajax para actualizar la interfaz sin cargar una página nueva desde el servidor. La API de tiempo del navegador no registra las actualizaciones de una sola página, sino que utilizan el tiempo de cambio de ruta.

CloudWatch RUM admite la supervisión de las cargas de páginas completas desde el servidor y de las actualizaciones de una sola página con las siguientes diferencias:
+ En lo que respecta al tiempo de cambio de ruta, no hay métricas proporcionadas por el navegador, como `tlsTime`, `timeToFirstByte` y así sucesivamente.
+ En lo relativo al tiempo de cambio de ruta, el campo `initiatorType` será `route_change`. 

El cliente web de CloudWatch RUM escucha las interacciones de los usuarios que pueden provocar un cambio de ruta y, cuando se registra una interacción así, el cliente web registra una marca de tiempo. El tiempo de cambio de ruta se iniciará entonces si se cumplen las siguientes condiciones:
+ Se ha utilizado una API de historial del navegador (excepto los botones de avance y retroceso del navegador) para realizar el cambio de ruta.
+ La diferencia entre la hora de detección del cambio de ruta y la última marca de tiempo de interacción del usuario es inferior a 1000 ms. Esto evita el sesgo de datos.

Luego, una vez da comienzo el tiempo de cambio de ruta, ese tiempo se completa si no hay solicitudes AJAX ni mutaciones DOM en curso. Seguidamente, se utilizará la marca de tiempo de la última actividad completada como marca de tiempo de finalización.

El tiempo de cambio de ruta expirará si hay solicitudes AJAX en curso o mutaciones de DOM durante más de 10 segundos (de forma predeterminada). En este caso, el cliente web de CloudWatch RUM ya no registrará el tiempo de este cambio de ruta.

Como resultado, la duración de un evento de cambio de ruta se calcula de la siguiente manera:

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

# Administre las aplicaciones que utilizan CloudWatch RUM
<a name="CloudWatch-RUM-manage"></a>

Siga los pasos de estas secciones para administrar el uso de CloudWatch RUM por parte de sus aplicaciones.

**Topics**
+ [¿Cómo encuentro un fragmento de código que ya he generado?](CloudWatch-RUM-find-code-snippet.md)
+ [Edición de la configuración del monitor de aplicaciones de CloudWatch RUM](CloudWatch-RUM-edit-application.md)
+ [Detención del uso de CloudWatch RUM o eliminación de un monitor de aplicaciones](CloudWatch-RUM-delete-appmonitor.md)

# ¿Cómo encuentro un fragmento de código que ya he generado?
<a name="CloudWatch-RUM-find-code-snippet"></a>

Para encontrar un fragmento de código de CloudWatch RUM que ya ha generado para una aplicación, siga estos pasos.

**Para encontrar un fragmento de código que ya ha generado**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Vaya a la pestaña **Configuración**, a la sección **Fragmentos de código**.

1. Elija **Copiar o Descargar** para la instrumentación correspondiente.

# Edición de la configuración del monitor de aplicaciones de CloudWatch RUM
<a name="CloudWatch-RUM-edit-application"></a>

Para cambiar la configuración de un monitor de aplicaciones, siga estos pasos. Puede cambiar cualquier configuración excepto el nombre del monitor de la aplicación.

**Para editar cómo la aplicación usa CloudWatch RUM**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija el botón situado junto al nombre de la aplicación y luego, **Actions** (Acciones), **Edit** (Editar).

1. Cambie cualquier configuración excepto el nombre de la aplicación. Para obtener más información acerca de la configuración, consulte [Creación de un monitor de aplicaciones de CloudWatch RUM para una aplicación web](CloudWatch-RUM-get-started-create-app-monitor.md).

1. Cuando termine, elija **Guardar**.

   Al cambiar la configuración, se cambia el fragmento de código. Ahora debe pegar el fragmento de código actualizado en la aplicación.

1. Una vez que se haya creado el fragmento de código, elija **Copiar al portapapeles** o **Descargar** y, a continuación, **Listo**.

   Para empezar a supervisar con la nueva configuración, inserte el fragmento de código en la aplicación.

# Detención del uso de CloudWatch RUM o eliminación de un monitor de aplicaciones
<a name="CloudWatch-RUM-delete-appmonitor"></a>

Para dejar de utilizar CloudWatch RUM con una aplicación, elimine el fragmento de código que RUM generó a partir del código de la aplicación.

Si desea eliminar un monitor de aplicación RUM, siga estos pasos.

**Para eliminar un monitor de aplicaciones**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, elija **Señales de aplicación**, **RUM**.

1. Elija el botón situado junto al nombre de la aplicación y luego, **Actions** (Acciones), **Delete** (Eliminar).

1. En el casillero de confirmación, ingrese **Delete** (Eliminar) y luego, elija **Delete** (Eliminar).

1. Si aún no lo ha hecho, elimine el fragmento de código de CloudWatch RUM del código de la aplicación.

# Solución de problemas de CloudWatch RUM
<a name="CloudWatch-RUM-troubleshooting"></a>

En esta sección se incluyen sugerencias para solucionar problemas de CloudWatch RUM.

## No hay datos para mi aplicación
<a name="CloudWatch-RUM-troubleshooting-nodata"></a>

En primer lugar, asegúrese de que el fragmento de código se ha insertado en la aplicación de forma correcta. Para obtener más información, consulte [Inserción del fragmento de código del monitor de aplicaciones de CloudWatch en la aplicación](CloudWatch-RUM-get-started-insert-code-snippet.md).

Si ese no es el problema, tal vez aún no hay tráfico a su aplicación. Genere algo de tráfico al acceder a su aplicación de la misma manera que lo haría un usuario.

## Los datos han dejado de registrarse para mi aplicación
<a name="CloudWatch-RUM-troubleshooting-nonewdata"></a>

Es posible que la aplicación se haya actualizado y que ya no contenga un fragmento de código de CloudWatch RUM. Verifique el código de la aplicación.

Otra posibilidad es que alguien haya actualizado el fragmento de código pero no haya insertado el fragmento actualizado en la aplicación. Siga las instrucciones que aparecen en [¿Cómo encuentro un fragmento de código que ya he generado?](CloudWatch-RUM-find-code-snippet.md) y busque el fragmento de código correcto actual y compárelo con el fragmento de código que se pega en la aplicación.