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

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

Avec CloudWatch RUM, vous pouvez effectuer une véritable surveillance des utilisateurs afin de collecter et de visualiser les données côté client concernant les performances de vos applications Web et mobiles à partir de sessions utilisateur réelles en temps quasi réel. Pour les applications Web, vous pouvez analyser les temps de chargement des pages, les erreurs côté client et le comportement des utilisateurs. Pour les applications mobiles, vous pouvez surveiller les temps de chargement de l'écran, les heures de lancement des applications, les erreurs réseau, les pannes et les problèmes spécifiques à la plate-forme tels que la non-réponse des applications Android (ANR) et les blocages d'applications iOS. Lorsque vous consultez ces données, vous pouvez les voir toutes agrégées ensemble ainsi que les ventilations par type d'appareil, système d'exploitation et autres caractéristiques de l'utilisation de vos applications.

Vous pouvez utiliser les données collectées pour identifier et corriger rapidement les problèmes de performance côté client. CloudWatch RUM vous aide à visualiser les anomalies des performances de votre application et à trouver les données de débogage pertinentes, telles que les messages d'erreur, les traces de pile et les sessions utilisateur. Vous pouvez également utiliser RUM pour comprendre l'étendue de l'impact sur l'utilisateur final, notamment le nombre d'utilisateurs, leur géolocalisation et browsers/devices leur utilisation.

Les données d'utilisateur final que vous collectez pour CloudWatch RUM sont conservées pendant 30 jours, puis automatiquement supprimées. Si vous souhaitez conserver les données de télémétrie RUM plus longtemps, vous pouvez demander au moniteur de l'application d'envoyer des copies de la télémétrie à CloudWatch Logs dans votre compte. Vous pouvez ensuite ajuster la période de rétention pour ce groupe de journaux.

Pour utiliser RUM, vous devez créer un *moniteur d'application* et fournir quelques informations. RUM génère un extrait de code que vous pouvez utiliser pour ajouter une injection de dépendance dans votre application. L'extrait extrait le code du client RUM selon les besoins. Le client RUM capture les données d'un pourcentage des sessions utilisateur de votre application, qui sont affichées dans un tableau de bord prédéfini. Vous pouvez spécifier le pourcentage de sessions utilisateur à partir desquelles collecter des données.

 CloudWatch RUM est intégré à [Application Signals](CloudWatch-Application-Monitoring-Sections.md), qui permet de découvrir et de surveiller les services de votre application, vos clients, les canaries Synthetics et les dépendances des services. Utilisez Application Signals pour consulter une liste ou une carte visuelle de vos services, consulter les indicateurs de santé en fonction de vos objectifs de niveau de service (SLOs) et effectuer une analyse descendante pour voir les traces de X-Ray corrélées afin de résoudre les problèmes de manière plus détaillée. Pour voir les demandes de page client RUM dans Application Signals, activez le suivi actif de X-Ray lors de la [création d'un moniteur d'applications](CloudWatch-RUM-get-started-create-app-monitor.md). Pour les applications Web, vous pouvez également l'activer en [configurant manuellement le client Web RUM](CloudWatch-RUM-configure-client.md). Vos clients RUM apparaissent sur la [Carte des applications](ServiceMap.md) associée à vos services, ainsi que sur la page [Détails du service](ServiceDetail.md) des services qu’ils appellent. 

Les clients RUM sont open source. Pour plus d'informations, consultez le [client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web), le SDK [AWS Distro pour OpenTelemetry (ADOT) Android et le SDK AWS](https://github.com/aws-observability/aws-otel-android) [Distro pour ( OpenTelemetry ADOT](https://github.com/aws-observability/aws-otel-swift)) iOS.

**Tarification RUM**

Pour plus d'informations sur les tarifs, consultez [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/). 

**Disponibilité dans les Régions**

CloudWatch Le RUM est actuellement disponible dans les régions suivantes :
+ USA Est (Virginie du Nord)
+ USA Est (Ohio)
+ USA Ouest (Californie du Nord)
+ USA Ouest (Oregon)
+ Afrique (Le Cap)
+ AWS GovCloud (USA Est)
+ AWS GovCloud (US-Ouest)
+ Asie-Pacifique (Mumbai)
+ Asie-Pacifique (Hyderabad)
+ Asie-Pacifique (Melbourne)
+ Asie-Pacifique (Osaka)
+ Asia Pacific (Seoul)
+ Asie-Pacifique (Singapour)
+ Asie-Pacifique (Sydney)
+ Asie-Pacifique (Jakarta)
+ Asie-Pacifique (Malaisie)
+ Asie-Pacifique (Thaïlande)
+ Asie-Pacifique (Tokyo)
+ Asie-Pacifique (Hong Kong)
+ Canada (Centre)
+ Europe (Francfort)
+ Europe (Irlande)
+ Europe (Londres)
+ Europe (Milan)
+ Europe (Paris)
+ Europe (Espagne)
+ Europe (Stockholm)
+ Europe (Zurich)
+ AWS European Sovereign Cloud (Allemagne)
+ Middle East (Bahrain)
+ Moyen-Orient (EAU)
+ Mexique (Centre)
+ Amérique du Sud (São Paulo)
+ Israël (Tel Aviv)
+ Canada-Ouest (Calgary)

# Configurer une application mobile pour utiliser CloudWatch RUM
<a name="CloudWatch-RUM-web-mobile"></a>

Pour surveiller les applications mobiles, vous devez créer un moniteur d'applications, le configurer pour les plateformes mobiles et intégrer le SDK AWS Distro for OpenTelemetry (ADOT) dans votre application. Mobile RUM utilise le OpenTelemetry protocole (OTLP) pour envoyer des données de télémétrie à un point de terminaison OTLP dédié. 

## Pour créer un moniteur d'applications pour une plateforme mobile
<a name="mobile-platform-app-monitor"></a>

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez **Add app monitor** (Ajouter un moniteur d'application).

1. Pour le **nom du moniteur d'application**, entrez un nom à utiliser pour identifier ce moniteur d'application dans la console CloudWatch RUM.

1. Sélectionnez **Android** ou **iOS** comme plateforme.

1. Sous **Stockage des données**, vous pouvez choisir de stocker des copies des événements et des intervalles du journal RUM OTEL dans des CloudWatch journaux et de configurer la conservation. Par défaut, le groupe de CloudWatch journaux Logs conserve les données pendant 30 jours. Vous pouvez ajuster la période de conservation dans la console CloudWatch Logs.

1. (Facultatif) Sous **Stratégie basée sur les ressources**, choisissez d'ajouter une politique basée sur les ressources pour contrôler qui peut envoyer des demandes au moniteur de votre application. Si vous choisissez **Créer une politique publique**, une politique de ressources sera jointe pour permettre à quiconque d'envoyer des demandes au moniteur de votre application. Pour de plus amples informations, veuillez consulter [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Pour activer le suivi AWS par X-Ray des sessions utilisateur échantillonnées, choisissez **Active tracing**, puis sélectionnez **Trace my service with AWS X-Ray**.

   Si cette option est sélectionnée, les intervalles OTEL générés lors des sessions utilisateur échantillonnées sont tracés. Vous pouvez ensuite voir les traces et les intervalles de ces sessions dans le tableau de bord RUM, ainsi que sur la carte des traces et les pages de détails des traces de X-Ray. Ces sessions utilisateur apparaîtront également sous forme de pages client dans Application Signals une fois que vous les aurez activées pour votre application.

1. (Facultatif) Pour ajouter des balises au moniteur de l'application :

   1. Choisissez **Tags**, puis **Ajouter un nouveau tag**.

   1. Pour **Key**, entrez le nom du tag. Vous pouvez ajouter une valeur facultative dans **Value**.

   1. Pour ajouter une autre étiquette, sélectionnez à nouveau **Add new tag (Ajouter une nouvelle étiquette)**.

   Pour plus d'informations, consultez la section [AWS Ressources de balisage](https://docs.aws.amazon.com/tagging/latest/userguide/tagging-resources.html) dans le guide de l'*utilisateur du AWS balisage et de l'éditeur de balises*.

1. Choisissez **Add app monitor** (Ajouter un moniteur d'application).

1. Dans la section **Exemple de code**, vous pouvez copier l'extrait de code à ajouter à votre application. À l'aide du SDK AWS Distro for OpenTelemetry (ADOT), vous pouvez choisir entre une **instrumentation manuelle** pour configurer la surveillance dans le code de votre application ou une **instrumentation Zero-Code** qui nécessite des modifications de configuration minimales.

   Pour les applications Android et iOS, Zero-Code Instrumentation est l'option la plus simple car elle initialise automatiquement la collecte de données télémétriques à l'aide d'un fichier de configuration. L'instrumentation manuelle vous permet de mieux contrôler le processus d'initialisation et de configuration.

1. Choisissez **Copy** (Copier) ou **Download** (Télécharger), puis **Done** (Terminé).

### Configuration de l'application iOS
<a name="CloudWatch-RUM-ios-setup"></a>

Pour les applications iOS, intégrez le [SDK AWS Distro for OpenTelemetry (ADOT) iOS](https://github.com/aws-observability/aws-otel-swift) pour activer la surveillance du RUM. Le SDK prend en charge iOS 16 et les versions ultérieures et fournit une instrumentation automatique pour les scénarios de performance courants.

### Configuration de l'application Android
<a name="CloudWatch-RUM-android-setup"></a>

Pour les applications Android, intégrez le [SDK AWS Distro for OpenTelemetry (ADOT) Android](https://github.com/aws-observability/aws-otel-android) pour activer la surveillance du RUM. Le SDK fournit une instrumentation automatique et prend en charge les modèles d'authentification signés et non signés.

## Authentification et sécurité
<a name="CloudWatch-RUM-authentication"></a>

Mobile RUM prend en charge les modèles d'authentification flexibles tels que définis dans leur SDKs.
+ Les applications iOS utilisent le [AWS SDK Distro for OpenTelemetry (ADOT) iOS](https://github.com/aws-observability/aws-otel-swift). 
+ Les applications Android utilisent le [AWS SDK Distro for OpenTelemetry (ADOT) Android](https://github.com/aws-observability/aws-otel-android).

# Politiques IAM pour utiliser RUM CloudWatch
<a name="CloudWatch-RUM-permissions"></a>

Pour pouvoir gérer entièrement CloudWatch RUM, vous devez être connecté en tant qu'utilisateur ou rôle IAM doté de la politique **AmazonCloudWatchRUMFullAccess** IAM. En outre, vous aurez peut-être besoin d'autres stratégies ou autorisations :
+ Pour créer un moniteur d'applications qui crée un nouveau pool d'identités Amazon Cognito à des fins d'autorisation, vous devez disposer du rôle **Admin** IAM ou de la **AdministratorAccess**politique IAM.
+ Pour créer un moniteur d'applications qui envoie des données à CloudWatch Logs, vous devez être connecté à un rôle ou à une politique IAM disposant des autorisations suivantes :

  ```
  {
      "Effect": "Allow",
      "Action": [
          "logs:PutResourcePolicy"
      ],
      "Resource": [
          "*"
      ]
  }
  ```
+ Pour activer les cartes JavaScript sources dans un moniteur d'applications, vous devez télécharger vos fichiers de carte source dans un compartiment Amazon S3. Votre rôle ou votre politique IAM nécessite des autorisations Amazon S3 spécifiques qui permettent de créer des compartiments Amazon S3, de définir des politiques de compartiment et de gérer les fichiers du compartiment. Pour des raisons de sécurité, limitez ces autorisations à des ressources spécifiques. L’exemple de politique ci-dessous restreint l’accès aux compartiments dont le nom contient `rum`, et utilise la clé de condition `aws:ResourceAccount` pour limiter les autorisations au compte principal uniquement.

  ```
  {
      "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}"
          }
      }
  }
  ```
+ Pour utiliser vos propres AWS KMS clés pour le chiffrement côté serveur sur votre bucket de carte source, votre rôle ou votre politique IAM nécessite des AWS KMS autorisations spécifiques qui permettent de créer une clé, de mettre à jour la politique de clé, d'utiliser la AWS KMS clé avec Amazon S3 et de définir la configuration de chiffrement de votre compartiment Amazon S3. Pour des raisons de sécurité, limitez ces autorisations à des usages précis. L’exemple ci-dessous restreint l’accès aux clés d’une région et d’un accountId spécifiques, et applique des restrictions S3 similaires à celles de l’exemple précédent. 

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

Les autres utilisateurs qui ont besoin de consulter les données CloudWatch RUM mais qui n'ont pas besoin de créer de ressources CloudWatch RUM peuvent bénéficier de cette **AmazonCloudWatchRUMReadOnlyAccess**politique.

# Configuration d'une application Web pour utiliser CloudWatch RUM
<a name="CloudWatch-RUM-get-started"></a>

Suivez les étapes décrites dans ces sections pour configurer votre application Web afin qu'elle commence à utiliser CloudWatch RUM pour collecter des données de performance à partir de sessions utilisateur réelles.

**Topics**
+ [Autorisez votre application Web à envoyer des données à AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Création d'un moniteur d'application CloudWatch RUM pour une application Web](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Modification de l'extrait de code pour configurer le client Web CloudWatch RUM (facultatif)](CloudWatch-RUM-modify-snippet.md)
+ [Insertion de l'extrait de code du moniteur d' CloudWatch applications dans votre application](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Tester la configuration de votre moniteur d' CloudWatch applications en générant des événements utilisateur](CloudWatch-RUM-get-started-generate-data.md)

# Autorisez votre application Web à envoyer des données à AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Vous disposez de quatre options pour configurer l’authentification des données :
+ Utilisez Amazon Cognito et laissez CloudWatch RUM créer un nouveau pool d'identités Amazon Cognito pour l'application. Cette méthode est la plus simple à configurer.

  Le groupe d'identités contiendra une identité non authentifiée. Cela permet au client Web CloudWatch RUM d'envoyer des données à CloudWatch RUM sans authentifier l'utilisateur de l'application.

  Un rôle IAM est attaché au groupe d'identités Amazon Cognito. L'identité non authentifiée Amazon Cognito permet au client Web d'assumer le rôle IAM autorisé à envoyer des données à RUM. CloudWatch 
+ Utiliser Amazon Cognito pour l’authentification. Si vous utilisez cette option, vous pouvez utiliser un groupe d’identités Amazon Cognito existant ou en créer un nouveau pour ce moniteur d’application. Si vous utilisez un groupe d’identités existant, vous devez également modifier le rôle IAM attaché au groupe d’identités. Utilisez cette option pour les groupes d’identités qui prennent en charge les utilisateurs non authentifiés. Vous ne pouvez utiliser des groupes d’identités que depuis la même région.
+ Utilisez l'authentification d'un fournisseur d'identité existant que vous avez déjà configuré. Dans ce cas, vous devez obtenir des informations d'identification du fournisseur d'identité et votre application doit transférer ces informations d'identification au client web RUM.

  Utilisez cette option pour les groupes d’identités qui ne prennent en charge que les utilisateurs authentifiés.
+ Utiliser des politiques basées sur les ressources pour gérer l’accès à votre moniteur d’application. Cela inclut la possibilité d'envoyer des demandes non authentifiées à CloudWatch RUM sans AWS informations d'identification. Pour en savoir plus sur les politiques basées sur les ressources et RUM, consultez [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

Les sections suivantes contiennent plus de détails sur ces options.

## Utilisation d'un groupe d'identités Amazon Cognito existant
<a name="CloudWatch-RUM-get-started-authorization-existingcognito"></a>

Si vous choisissez d'utiliser un pool d'identités Amazon Cognito, vous devez le spécifier lorsque vous ajoutez l'application à CloudWatch RUM. Le groupe doit prendre en charge l'activation de l'accès à des identités non authentifiées. Vous ne pouvez utiliser des groupes d’identités que depuis la même région.

Vous devez également ajouter les autorisations suivantes à la stratégie IAM attachée au rôle IAM associé à ce groupe d'identités.

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

****  

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

------

Amazon Cognito enverra ensuite le jeton de sécurité nécessaire pour permettre à votre application d'accéder CloudWatch à RUM.

## Fournisseur tiers
<a name="CloudWatch-RUM-get-started-authorization-thirdparty"></a>

Si vous choisissez l'authentification privée d'un fournisseur tiers, vous devez obtenir des informations d'identification du fournisseur d'identité et les transférer à AWS. Le meilleur moyen d'y parvenir consiste à utiliser un *fournisseur de jetons de sécurité*. Vous pouvez utiliser n'importe quel fournisseur de jetons de sécurité, y compris Amazon Cognito avec. AWS Security Token Service Pour plus d'informations AWS STS, consultez la section [Welcome to the AWS Security Token Service API Reference](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). 

Si vous souhaitez utiliser Amazon Cognito comme fournisseur de jetons dans ce scénario, vous pouvez configurer Amazon Cognito pour qu'il fonctionne avec un fournisseur d'authentification. Pour plus d'informations, consultez [Démarrez avec les groupes d'identités Amazon Cognito (identités fédérées)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html).

Après avoir configuré Amazon Cognito pour qu'il fonctionne avec votre fournisseur d'identité, vous devez également effectuer les opérations suivantes :
+ Créez un rôle IAM avec les autorisations suivantes. Votre application utilisera ce rôle pour accéder à AWS.

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

****  

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

------
+ Ajoutez ce qui suit à votre application pour qu'elle transmette les informations d'identification de votre fournisseur à CloudWatch RUM. Insérez cette ligne pour qu'elle s'exécute après qu'un utilisateur s'est connecté à votre application et que celle-ci a reçu les informations d'identification à utiliser pour accéder à AWS.

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

[Pour plus d'informations sur les fournisseurs d'informations d'identification dans le AWS JavaScript SDK, voir [Configuration des informations d'identification dans un navigateur Web](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) dans le guide du développeur v3 pour le SDK JavaScript, [Configuration des informations d'identification dans un navigateur Web dans](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) le guide du développeur v2 pour le SDK pour JavaScript, et @aws -sdk/credential-providers.](https://www.npmjs.com/package/@aws-sdk/credential-providers) 

Vous pouvez également utiliser le SDK du client Web CloudWatch RUM pour configurer les méthodes d'authentification du client Web. Pour plus d'informations sur le SDK du client Web, consultez la section SDK du [client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web). 

# Création d'un moniteur d'application CloudWatch RUM pour une application Web
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Pour commencer à utiliser CloudWatch RUM avec votre application, vous devez créer un *moniteur d'applications*. Lorsque le moniteur d'applications est créé, RUM génère un extrait de code que vous pouvez coller dans votre application. L'extrait extrait le code du client RUM. Le client RUM capture les données des sessions utilisateur de votre application et les envoie à RUM.

## Pour créer un moniteur d'applications pour une plateforme Web
<a name="web-platform-app-monitor"></a>

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez **Add app monitor** (Ajouter un moniteur d'application).

1. Pour le **nom du moniteur d'application**, entrez un nom à utiliser pour identifier ce moniteur d'application dans la console CloudWatch RUM.

1. Sélectionnez **Web** comme plate-forme.

1. Pour **Liste des domaines d’application**, saisissez les noms de domaine enregistrés sur lesquels votre application dispose d’une autorité administrative. Vous pouvez également utiliser un caractère générique `*` pour autoriser les sous-domaines ou domaines de premier niveau (par exemple, \$1.amazon.com, amazon.\$1, \$1.amazon.\$1).

1. Pour **Configure RUM data collection** (Configurer la collecte des données RUM), indiquez si vous souhaitez que le moniteur d'application collecte chacun des éléments suivants :
   + **Performance telemetry** (Télémétrie de performance) : collecte des informations sur le chargement des pages et les temps de chargement des ressources.
   + **JavaScript erreurs** — Recueille des informations sur les JavaScript erreurs non gérées signalées par votre application

     Vous pouvez sélectionner **Unminify JavaScript error stack traces pour corriger les** erreurs non minimisées. JavaScript Pour utiliser cette fonctionnalité, chargez vos fichiers de sourçage dans un compartiment ou dossier Amazon S3, puis indiquez l’URI Amazon S3 correspondant. Une fois activé, RUM utilisera ces cartes sources et enrichira les événements JavaScript d'erreur en ajoutant la trace de pile non minimisée. Notez qu'une fois activée, cette fonctionnalité ne traite que les nouveaux événements JavaScript d'erreur et ne peut pas être utilisée sur des données collectées précédemment. Pour de plus amples informations, veuillez consulter [Activation de la minimisation des traces de pile JavaScript d'erreurs](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **HTTP errors** (Erreurs HTTP) : collecte des informations sur les erreurs HTTP levées par votre application.

   La sélection de ces options fournit plus d'informations sur votre application, mais génère également davantage d'événements CloudWatch RUM et entraîne donc des frais supplémentaires.

   Si vous ne sélectionnez aucune de ces options, le moniteur de l'application collecte toujours les événements et les pages de démarrage de session IDs afin que vous puissiez voir combien d'utilisateurs utilisent votre application, y compris les ventilations par type et version de système d'exploitation, type et version de navigateur, type d'appareil et emplacement.

1. Sélectionnez **cette option pour autoriser le client Web CloudWatch RUM à définir des cookies** si vous souhaitez pouvoir collecter des utilisateurs IDs et des sessions à IDs partir d'échantillons de sessions utilisateur. Les utilisateurs IDs sont générés aléatoirement par RUM. Pour de plus amples informations, veuillez consulter [CloudWatch Cookies du client Web RUM (ou technologies similaires)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. Pour **Session samples** (Exemples de session), saisissez le pourcentage de sessions utilisateur qui seront utilisées pour collecter des données RUM. La valeur par défaut est 100 %. Si vous réduisez cette valeur, vous obtiendrez moins de données, mais vos frais seront réduits. Pour plus d'informations sur la tarification RUM, consultez [Tarification RUM](CloudWatch-RUM.md#RUMpricing).

1. Les données d'utilisateur final que vous collectez pour CloudWatch RUM sont conservées pendant 30 jours, puis supprimées. Si vous souhaitez conserver des copies des événements RUM dans les CloudWatch journaux et configurer la durée de conservation de ces copies, choisissez **Cocher cette option pour stocker les données de télémétrie de votre application dans votre compte CloudWatch Logs** sous Stockage **des données**. Par défaut, le groupe de CloudWatch journaux Logs conserve les données pendant 30 jours. Vous pouvez ajuster la période de conservation dans la console CloudWatch Logs.

1. (Facultatif) Ajoutez une politique basée sur les ressources à votre moniteur d’application pour contrôler qui peut envoyer des requêtes `PutRumEvents` à votre moniteur. Si vous sélectionnez **Créer une politique publique**, une politique de ressources sera attachée à votre moniteur d’application, ce qui permettra à n’importe qui d’envoyer des requêtes `PutRumEvents` à votre moniteur. Pour plus d’informations sur cette méthode, consultez [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Si vous avez joint une politique basée sur les ressources à l'étape précédente, vous n'avez pas besoin de signer les demandes adressées à CloudWatch RUM avec des AWS informations d'identification et vous pouvez ignorer la configuration de l'autorisation. Sinon, pour **Autorisation**, indiquez si vous souhaitez utiliser un nouvel groupe d’identités Amazon Cognito, un groupe existant, ou un autre fournisseur d’identité. La création d'un nouveau groupe d'identités est l'option la plus simple et ne nécessite aucune autre étape de configuration. Pour plus d’informations, consultez [Autorisez votre application Web à envoyer des données à AWS](CloudWatch-RUM-get-started-authorization.md).

   La création d'un nouveau groupe d'identités Amazon Cognito nécessite des autorisations administratives. Pour de plus amples informations, veuillez consulter [Politiques IAM pour utiliser RUM CloudWatch](CloudWatch-RUM-permissions.md).

1. (Facultatif) Par défaut, lorsque vous ajoutez l'extrait de code RUM à votre application, le client Web injecte la JavaScript balise pour surveiller l'utilisation dans le code HTML de toutes les pages de votre application. Pour modifier ce comportement, choisissez **Configure pages** (Configurer les pages), puis choisissez **Include only these pages** (Inclure uniquement ces pages) ou **Exclude these pages** (Exclure ces pages). Ensuite, spécifiez les pages à inclure ou à exclure. Pour spécifier une page à inclure ou à exclure, saisissez-la complète URLs. Pour spécifier des pages supplémentaires, choisissez **Add URL** (Ajouter une URL).

1. Pour activer le AWS X-Ray suivi des sessions utilisateur échantillonnées par le moniteur de l'application, choisissez **Suivi actif**, puis sélectionnez **Tracer mon service avec AWS X-Ray**.

   Si vous sélectionnez cette option, les demandes `XMLHttpRequest` et `fetch` effectuées pendant les sessions utilisateur échantillonnées par le moniteur d'application sont suivies. Vous pouvez ensuite voir les suivis et les segments de ces sessions utilisateur dans le tableau de bord RUM, ainsi que sur les pages de la carte de suivi X-Ray et de détails des suivis X-Ray. Ces sessions utilisateur apparaîtront également sous forme de pages client dans [Application Signals](CloudWatch-Application-Monitoring-Sections.md) une fois que vous les aurez activées pour votre application.

   En apportant des modifications de configuration supplémentaires au client Web CloudWatch RUM, vous pouvez ajouter un en-tête de trace X-Ray aux requêtes HTTP afin de permettre le end-to-end suivi des sessions utilisateur jusqu'aux services AWS gérés en aval. Pour de plus amples informations, veuillez consulter [Activation du end-to-end traçage par rayons X](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Facultatif) Pour ajouter des identifications au moniteur d'application, choisissez**Tags** (Identifications), **Add new tag** (Ajouter une nouvelle identification).

   Ensuite, pour **Key** (Clé), saisissez un nom pour l'identification. Vous pouvez ajouter une valeur en option pour la balise dans **Value (Valeur)**. 

   Pour ajouter une autre étiquette, sélectionnez à nouveau **Add new tag (Ajouter une nouvelle étiquette)**.

   Pour plus d'informations, consultez [Identification des ressources  AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).

1. Choisissez **Add app monitor** (Ajouter un moniteur d'application).

1. Dans la section **Sample code** (Exemple de code), vous pouvez copier l'extrait de code à utiliser pour ajouter à votre application. Nous vous recommandons de choisir **JavaScript**ou **TypeScript**d'utiliser NPM pour installer le client Web CloudWatch RUM en tant que JavaScript module.

   Vous pouvez également choisir le **format HTML** pour utiliser un réseau de diffusion de contenu (CDN) afin d'installer le client Web CloudWatch RUM. L'inconvénient de l'utilisation d'un CDN est que le client web est souvent bloqué par des bloqueurs de publicités.

1. Choisissez **Copy** (Copier) ou **Download** (Télécharger), puis **Done** (Terminé).

# Modification de l'extrait de code pour configurer le client Web CloudWatch RUM (facultatif)
<a name="CloudWatch-RUM-modify-snippet"></a>

Vous pouvez modifier l'extrait de code avant de l'insérer dans votre application, pour activer ou désactiver plusieurs options. Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM.](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md)

Quatre options de configuration importantes sont à connaître, comme expliqué dans les sections suivantes.

## Empêcher la collecte de ressources URLs susceptibles de contenir des informations personnelles
<a name="CloudWatch-RUM-resourceURL"></a>

Par défaut, le client Web CloudWatch RUM est configuré pour enregistrer URLs les ressources téléchargées par l'application. Ces ressources incluent des fichiers HTML, des images, des JavaScript fichiers CSS, des fichiers, etc. Certaines applications URLs peuvent contenir des informations personnelles identifiables (PII).

Si tel est le cas pour votre application, nous vous recommandons vivement de désactiver la collecte de ressources `recordResourceUrl: false` en URLs définissant la configuration de l'extrait de code, avant de l'insérer dans votre application.

## Enregistrement manuel des consultations de page
<a name="CloudWatch-RUM-pageload"></a>

Par défaut, le client web enregistre les consultations de page lorsque la page se charge pour la première fois et lorsque l'API d'historique du navigateur est appelée. L'ID de page par défaut est `window.location.pathname`. Toutefois, dans certains cas, vous devrez peut-être remplacer ce comportement et utiliser l'application pour qu'elle enregistre les consultations de page par programmation. Cela vous permet de contrôler l'ID de page et le moment où il est enregistré. Prenons l'exemple d'une application Web dotée d'un URI avec un identifiant variable, tel que `/entity/123` ou `/entity/456`. Par défaut, CloudWatch RUM génère un événement d'affichage de page pour chaque URI avec un ID de page distinct correspondant au nom du chemin, mais vous pouvez plutôt les regrouper par le même identifiant de page. Pour ce faire, désactivez l'automatisation de la consultation de page du client Web à l'aide de la configuration `disableAutoPageView`, puis utilisez la commande `recordPageView` pour définir l'ID de page souhaité. Pour plus d'informations, consultez la section [Configurations spécifiques à l'application sur](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md). GitHub

**Exemple de script intégré :**

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

**JavaScript exemple de module :**

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

## Activation du end-to-end traçage par rayons X
<a name="CloudWatch-RUM-xraytraceheader"></a>

Lorsque vous créez le moniteur d'application, sélectionnez **Trace my service with AWS X-Ray** (Suivre mon service avec ) pour activer le suivi des demandes `XMLHttpRequest` et `fetch` effectuées pendant les sessions utilisateur échantillonnées par le moniteur d'application. Vous pouvez ensuite voir les traces de ces requêtes HTTP dans le tableau de bord CloudWatch RUM, ainsi que sur les pages de détails de X-Ray Trace Map et Trace.

Par défaut, ces suivis côté client ne sont pas connectés à des suivis côté serveur en aval. Pour connecter les traces côté client aux traces côté serveur et activer le end-to-end suivi, définissez l'`addXRayTraceIdHeader`option sur `true` dans le client Web. Cela oblige le client Web CloudWatch RUM à ajouter un en-tête de trace X-Ray aux requêtes HTTP.

Le bloc de code suivant présente un exemple d'ajout de suivis côté client. Certaines options de configuration sont omises de cet exemple pour des raisons de lisibilité.

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

**Avertissement**  
La configuration du client Web CloudWatch RUM pour ajouter un en-tête de trace X-Ray aux requêtes HTTP peut entraîner l'échec du partage de ressources entre origines (CORS) ou l'invalidation de la signature de la demande si celle-ci est signée avec SigV4. Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md). Nous vous recommandons fortement de tester votre application avant d'ajouter un en-tête de suivi X-Ray côté client dans un environnement de production.

Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http)

## Envoi de demandes non signées à RUM CloudWatch
<a name="CloudWatch-RUM-unsigned"></a>

Par défaut, le client web RUM signe toutes les requêtes envoyées à RUM. Si vous définissez `signing:false` la configuration du client, les demandes ne seront pas signées lorsqu'elles seront envoyées à CloudWatch RUM. Les données ne seront ingérées dans RUM que si une stratégie publique basée sur les ressources est associée au moniteur d’application. Pour de plus amples informations, veuillez consulter [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

# Insertion de l'extrait de code du moniteur d' CloudWatch applications dans votre application
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

Ensuite, vous devez insérer dans votre application l'extrait de code que vous avez créé dans la section précédente.

**Avertissement**  
Le client web, téléchargé et configuré par l'extrait de code, utilise des cookies (ou des technologies semblables) pour vous aider à collecter les données des utilisateurs finaux. Avant d'insérer l'extrait de code, consultez [Filtrage par attributs de métadonnées dans la consoleProtection et confidentialité des données avec CloudWatch RUM](CloudWatch-RUM-privacy.md).

Si vous n'avez pas l'extrait de code précédemment généré, vous pouvez le trouver en suivant les instructions dans [Comment puis-je trouver un extrait de code que j'ai déjà généré ?](CloudWatch-RUM-find-code-snippet.md).

**Pour insérer l'extrait de code CloudWatch RUM dans votre application**

1. Insérez l'extrait de code que vous avez copié ou téléchargé dans la section précédente dans l'élément `<head>` de votre application. Insérez-le avant l'élément `<body>` ou toute autre identification `<script>`.

   L'extrait suivant représente un exemple d'extrait de code généré :

   ```
   <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 votre application est une application web multipage, vous devez répéter l'étape 1 pour chaque page HTML que vous souhaitez inclure dans la collecte de données.

# Tester la configuration de votre moniteur d' CloudWatch applications en générant des événements utilisateur
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Une fois que vous avez inséré l'extrait de code et que votre application mise à jour est en cours d'exécution, vous pouvez effectuer un test en générant manuellement des événements utilisateur. Pour ce test, nous vous recommandons d'effectuer les opérations suivantes. Ce test entraîne des frais de CloudWatch RUM standard.
+ Parcourez les pages de votre application web.
+ Créez plusieurs sessions utilisateur à l'aide de différents navigateurs et appareils.
+ Envoyez de demandes.
+  JavaScript Provoquer des erreurs.

Après avoir généré certains événements, visualisez-les dans le tableau de bord CloudWatch RUM. Pour de plus amples informations, veuillez consulter [Consulter le tableau de bord CloudWatch du RUM](CloudWatch-RUM-view-data.md).

L'affichage des données des sessions utilisateur dans le tableau de bord peut prendre jusqu'à 15 minutes.

Si vous ne voyez pas de données 15 minutes après avoir généré des événements dans l'application, reportez-vous à la section [Résolution des problèmes liés CloudWatch à](CloudWatch-RUM-troubleshooting.md).

# Utilisation de politiques basées sur les ressources avec RUM CloudWatch
<a name="CloudWatch-RUM-resource-policies"></a>

Vous pouvez associer une politique de ressources à un moniteur d'application CloudWatch RUM. Par défaut, aucune politique de ressources n'est attachée aux moniteurs d'applications. CloudWatch Les politiques basées sur les ressources RUM ne prennent pas en charge l'accès entre comptes.

Pour en savoir plus sur les politiques relatives aux AWS ressources, consultez les sections Politiques basées sur l'[identité et politiques basées sur les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).

Pour en savoir plus sur la façon dont les politiques basées sur les identités et les politiques basées sur les ressources sont évaluées, consultez [Logique d’évaluation des politiques](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html).

Pour en savoir plus sur la syntaxe des politiques IAM, consultez [Référence des éléments de politique IAM JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html).

## Actions prises en charge
<a name="RUM-resource-policies-actions"></a>

Les politiques basées sur les ressources appliquées aux moniteurs d’application prennent en charge l’action `rum:PutRumEvents`.

## Exemples de politiques à utiliser avec CloudWatch RUM
<a name="RUM-resource-policies-samples"></a>

L’exemple suivant autorise toute personne à écrire des données dans votre moniteur d’application, y compris celles ne disposant pas d’informations d’identification 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": "*"
        }
    ]
}
```

------

Vous pouvez modifier cette politique pour bloquer certaines adresses IP sources en utilisant la clé de condition `aws:SourceIp`. Dans cet exemple, en utilisant cette politique, PutRumEvents l'adresse IP répertoriée sera rejetée. Toutes les autres requêtes en provenance d’autres adresses IP seront acceptées. Pour plus d’informations sur cette clé de condition, consultez [Propriétés du réseau](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-network-properties) dans le Guide de l’utilisateur 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"
                }
            }
        }
    ]
}
```

------

En outre, vous pouvez utiliser la clé de contexte de `rum:alias` service pour contrôler les demandes acceptées. 

Pour les moniteurs d'applications Web, vous devez configurer votre client Web pour qu'il envoie à `Alias` l'aide de la version 1.20 ou ultérieure du client Web CloudWatch RUM, comme décrit dans Configurations [spécifiques à l'application sur](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md). GitHub

Pour les moniteurs d'applications mobiles, vous devez configurer votre instrumentation conformément au SDK.
+ Les applications iOS utilisent le [AWS SDK Distro for OpenTelemetry (ADOT) iOS](https://github.com/aws-observability/aws-otel-swift). 
+ Les applications Android utilisent le [AWS SDK Distro for OpenTelemetry (ADOT) Android](https://github.com/aws-observability/aws-otel-android).

Dans l'exemple suivant, la politique de ressources exige que les demandes contiennent l'un `alias1` ou `alias2` l'autre ou que l'événement soit accepté.

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

# Configuration du client Web CloudWatch RUM
<a name="CloudWatch-RUM-configure-client"></a>

Vos applications peuvent utiliser l'un des extraits de code générés par CloudWatch RUM pour installer le client Web CloudWatch RUM. Les extraits générés prennent en charge deux méthodes d'installation : en tant que JavaScript module via NPM ou à partir d'un réseau de diffusion de contenu (CDN). Pour de meilleures performances, nous vous recommandons d'utiliser la méthode d'installation NPM. Pour plus d'informations sur l'utilisation de cette méthode, consultez la section [Installation en tant que JavaScript module](https://github.com/aws-observability/aws-rum-web/blob/main/docs/npm_installation.md).

Si vous utilisez l'option d'installation du CDN, les bloqueurs de publicité peuvent bloquer le CDN par défaut fourni par RUM. CloudWatch Cela désactive la surveillance des applications pour les utilisateurs qui ont installé des bloqueurs de publicité. Pour cette raison, nous vous recommandons d'utiliser le CDN par défaut uniquement pour l'intégration initiale avec CloudWatch RUM. Pour plus d'informations sur les moyens d'atténuer ce problème, consultez [Instrument the application](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#instrument-the-application) (Instrumentation de l'application).

L'extrait de code se trouve dans l'identification `<head>` d'un fichier HTML et installe le client web en le téléchargeant, puis en le configurant pour l'application qu'il surveille. Cet extrait est une fonction auto-exécutable qui ressemble à l'exemple suivant. Dans cet exemple, le corps de la fonction de l'extrait de code a été omis pour des raisons de lisibilité.

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

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

L'extrait de code accepte six arguments :
+ Un espace de noms permettant d'exécuter des commandes sur le client web, par exemple `'cwr'`
+ L'ID du moniteur d'application, par exemple `'00000000-0000-0000-0000-000000000000'`
+ La version de l'application, par exemple `'1.0.0'`
+ La AWS région du moniteur de l'application, telle que `'us-west-2'`
+ L'URL du client web, par exemple `'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js'`
+ Des options de configuration spécifiques à l'application. Pour plus d'informations, consultez la section suivante.

## Omission des erreurs
<a name="CloudWatch-RUM-configure-ignore-errors"></a>

Le client Web CloudWatch RUM écoute tous les types d'erreurs qui se produisent dans vos applications. Si votre application émet JavaScript des erreurs que vous ne souhaitez pas afficher dans le tableau de bord CloudWatch RUM, vous pouvez configurer le client Web CloudWatch RUM pour filtrer ces erreurs afin de ne voir que les événements d'erreur pertinents sur le tableau de bord CloudWatch RUM. Par exemple, vous pouvez choisir de ne pas afficher certaines JavaScript erreurs dans le tableau de bord parce que vous avez déjà identifié un correctif pour celles-ci et que le volume de ces erreurs masque d'autres erreurs. Vous pouvez également ignorer les erreurs que vous ne pouvez pas corriger car elles appartiennent à une bibliothèque appartenant à un tiers.

Pour plus d'informations sur la manière d'instrumenter le client Web pour filtrer des JavaScript erreurs spécifiques, consultez l'exemple dans la section [Erreurs](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md#errors) dans la documentation Github du client Web.

## Options de configuration
<a name="CloudWatch-RUM-configure-options"></a>

Pour plus d'informations sur les options de configuration disponibles pour le client Web CloudWatch RUM, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md)

# Activation de la minimisation des traces de pile JavaScript d'erreurs
<a name="CloudWatch-RUM-JavaScriptStackTraceSourceMaps"></a>

Lorsque le code JavaScript source de votre application Web est réduit, les traces de la pile d'erreurs peuvent être difficiles à lire. Vous pouvez activer la minimisation des traces de la pile en téléchargeant vos cartes sources sur Amazon S3. CloudWatch RUM récupérera les cartes sources pour faire correspondre les numéros de ligne et de colonne du code source minifié au code source non minifié d'origine. Cela rendra vos suivis d’erreurs plus lisibles et vous aidera à identifier plus facilement l’emplacement de l’erreur dans le code d’origine. 

## Exigences et syntaxe
<a name="CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps"></a>

Les fichiers de sourçage sont essentiels pour le débogage et le suivi des problèmes dans votre application Web à travers différentes versions. Assurez-vous que chaque version de votre application dispose d’un fichier de sourçage unique. Chaque version doit avoir son propre releaseId unique. Le releaseId doit être une chaîne de 1 à 200 caractères, composée uniquement de lettres, chiffres, traits de soulignement, traits d’union, deux-points, barres obliques et points. Pour ajouter les métadonnées `releaseId` sous forme de métadonnées aux événements RUM, configurez le client Web CloudWatch RUM.

Les fichiers de sourçage doivent être des fichiers JSON simples respectant la structure définie dans la [spécification Source Map V3](https://sourcemaps.info/spec.html). Les champs obligatoires sont : `version`, `file`, `sources`, `names` et `mappings`.

Assurez-vous que la taille de chaque fichier de sourçage ne dépasse pas 50 Mo. De plus, le service RUM n’extrait au maximum que 50 Mo de fichiers de sourçage par suivi de pile. Si nécessaire, divisez votre code source en plusieurs fragments plus petits. Pour plus d’informations, consultez la section [Fractionnement du code avec WebpackJS](https://webpack.js.org/guides/code-splitting/).

**Topics**
+ [Exigences et syntaxe](#CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps)
+ [Configuration de votre politique de ressources du compartiment Amazon S3 pour permettre l’accès du service RUM](#CloudWatch-RUM-ConfigureS3)
+ [Chargement des fichiers de sourçage](#CloudWatch-RUM-UploadSourceMaps)
+ [Configurez ReleaseID dans votre client Web CloudWatch RUM](#CloudWatch-RUM-ConfigureRumID)
+ [Activation CloudWatch du moniteur d'applications RUM pour minimiser les traces de stack JavaScript](#CloudWatch-RUM-unminifyjavascript)
+ [Affichage des suivis de pile déminifiées dans la console RUM](#CloudWatch-RUM-viewunminifiedstacktraces)
+ [Afficher des traces de pile non minimisées dans les journaux CloudWatch](#CloudWatch-RUM-viewunminifiedstacktracesCWL)
+ [Résolution des problèmes liés aux fichiers de sourçage](#CloudWatch-RUM-troubleshootsourcemaps)

## Configuration de votre politique de ressources du compartiment Amazon S3 pour permettre l’accès du service RUM
<a name="CloudWatch-RUM-ConfigureS3"></a>

Assurez-vous que votre compartiment Amazon S3 se trouve dans la même région que votre appMonitor RUM. Configurez votre compartiment Amazon S3 afin de permettre au service RUM d’extraire les fichiers de sourçage. Incluez les clés de contexte globales de condition `aws:SourceArn` et `aws:SourceAccount` pour limiter les autorisations du service aux ressources concernées. C’est le moyen le plus efficace de se protéger contre le [problème du député confus](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).

L’exemple ci-dessous montre comment utiliser ces clés de contexte globales `aws:SourceArn` et `aws:SourceAccount` dans Amazon S3 pour éviter le problème de confusion d’identité.

------
#### [ 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 vous utilisez des AWS KMS clés pour chiffrer les données, assurez-vous que la politique de ressources de la clé est configurée de la même manière pour inclure les clés contextuelles `aws:SourceArn` et les clés de contexte de condition `aws:SourceAccount` globale afin de permettre au service RUM d'utiliser les clés pour récupérer les fichiers de carte source.

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

------

## Chargement des fichiers de sourçage
<a name="CloudWatch-RUM-UploadSourceMaps"></a>

Configurez votre JavaScript bundle pour générer des cartes sources lors de la minification. Lorsque vous créez votre application, le bundle crée un répertoire (par exemple, dist) contenant les JavaScript fichiers minifiés et les cartes sources correspondantes. Vous trouverez un exemple ci-dessous.

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

Chargez les fichiers de sourçage dans votre compartiment Amazon S3. Les fichiers doivent être placés dans un dossier portant le nom du `releaseId`. Par exemple, si le nom de votre compartiment est `my-application-source-maps` et que le `releaseId` est 2.0.0, alors le fichier de sourçage se trouvera à l’emplacement suivant :

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

Pour automatiser le chargement de vos fichiers de sourçage, vous pouvez créer le script bash suivant et l’exécuter dans le cadre de votre processus de compilation.

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

## Configurez ReleaseID dans votre client Web CloudWatch RUM
<a name="CloudWatch-RUM-ConfigureRumID"></a>

CloudWatch RUM utilise le fichier configuré `releaseId` pour déterminer le dossier dans lequel récupérer les fichiers de carte source. Nommez le `releaseId` avec le même nom que le dossier contenant vos fichiers de sourçage. Si vous avez utilisé le script bash fourni ci-dessus ou un script similaire, le script `releaseId` configuré doit être le même que celui configuré dans votre client Web CloudWatch RUM. Vous devez utiliser la version 1.21.0 ou ultérieure du client Web 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
}
```

## Activation CloudWatch du moniteur d'applications RUM pour minimiser les traces de stack JavaScript
<a name="CloudWatch-RUM-unminifyjavascript"></a>

Pour minimiser les traces de JavaScript stack, réglez le SourceMap statut du moniteur de l'application sur. `ENABLED` Indiquez l’URI Amazon S3 du compartiment ou du dossier contenant tous les fichiers de sourçage de votre moniteur d’application.

Si les fichiers de sourçage sont stockés directement dans le compartiment principal (et non dans un sous-dossier), l’URI Amazon S3 doit être au format `Amazon S3://BUCKET_NAME`. Dans ce cas, les fichiers de sourçage doivent se trouver à l’emplacement suivant.

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

Si le répertoire enfant est la racine, l’URI Amazon S3 doit être au format `Amazon S3://BUCKET_NAME/DIRECTORY`. Dans ce cas, les fichiers de sourçage doivent se trouver à l’emplacement suivant.

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

## Affichage des suivis de pile déminifiées dans la console RUM
<a name="CloudWatch-RUM-viewunminifiedstacktraces"></a>

Après avoir chargé vos cartes sources sur Amazon S3, activé les cartes sources sur le moniteur de votre application RUM et déployé votre application Web avec le client Web `releaseId` configuré dans le client Web CloudWatch RUM, sélectionnez **Events** dans la console RUM. Cet onglet affiche les données brutes des événements RUM. Filtrez selon le type d’événement d’erreur JS et affichez le dernier événement d’erreur JS. Vous verrez le suivi de pile déminifiée dans le nouveau champ `event_details.unminifiedStack`, disponible uniquement pour les événements ingérés après l’activation de cette fonctionnalité.

## Afficher des traces de pile non minimisées dans les journaux CloudWatch
<a name="CloudWatch-RUM-viewunminifiedstacktracesCWL"></a>

Activez le stockage des événements RUM dans CloudWatch les journaux en activant le **stockage des données**. Une fois cette option activée, vous pouvez rechercher le nouveau champ **event\$1details.unminifiedStack**. Cela vous permet d'analyser les tendances et de relier les problèmes rencontrés au cours de plusieurs sessions à l'aide de requêtes CloudWatch Logs.

## Résolution des problèmes liés aux fichiers de sourçage
<a name="CloudWatch-RUM-troubleshootsourcemaps"></a>

CloudWatch RUM fournit des métriques prêtes à l'emploi pour résoudre les problèmes de configuration de votre carte source. Ces métriques sont publiées dans l'espace de noms de métrique nommé `AWS/RUM`. Les métriques suivantes sont publiées avec une dimension application\$1name. La valeur de cette dimension est le nom du moniteur d'application. Ces métriques sont également publiées avec une dimension `aws:releaseId`. La valeur de cette dimension est celle `releaseId` associée à l'événement JavaScript d'erreur.


| MetricName | Unité | Description | 
| --- | --- | --- | 
|  UnminifyLineFailureCount  |  Nombre  |  Nombre de lignes de suivi de pile dans l’événement d’erreur JS qui n’ont pas pu être déminifiées. Des détails supplémentaires sur l’échec sont ajoutés à la ligne spécifique concernée dans le champ event\$1details.unminifiedStack.  | 
|  UnminifyLineSuccessCount  |  Nombre  | Nombre de lignes de suivi de pile dans l’événement d’erreur JS qui ont été déminifiées avec succès. | 
| UnminifyEventFailureCount | Nombre | Nombre d’événements d’erreur JS pour lesquels aucune ligne n’a pu être déminifiée. Des détails supplémentaires sur ces échecs sont ajoutés dans le champ event\$1details.unminifiedStack. | 
| UnminifyEventSuccessCount | Nombre | Nombre d’événements d’erreur JS pour lesquels au moins une ligne de suivi de pile a été déminifiée avec succès. | 

CloudWatch RUM peut ne pas déminifier une ligne dans le stack trace pour diverses raisons, notamment, mais sans s'y limiter :
+ Impossible d’extraire le fichier de sourçage correspondant en raison de problèmes d’autorisations. Assurez-vous que la politique de ressources du compartiment est correctement configurée.
+ Le fichier de sourçage correspondant est introuvable. Assurez-vous que les fichiers de carte source ont été téléchargés dans le compartiment ou le dossier approprié portant le même nom que le ReleaseID configuré dans votre client Web CloudWatch RUM.
+ Le fichier de sourçage est trop volumineux. Divisez votre code source en fragments plus petits.
+ 50 Mo de fichiers de sourçage ont déjà été extraits pour le suivi de pile. Réduisez la longueur de suivi de pile, car 50 Mo est la limite imposée par le service.
+ Le fichier de sourçage est invalide ou n’a pas pu être indexé. Vérifiez qu’il s’agit bien d’un fichier JSON conforme à la spécification Source Map V3, contenant les champs obligatoires suivants : version, fichier, sources, noms et mappages.
+ Le fichier de sourçage n’a pas permis d’associer le code minifié au suivi de pile déminifiée. Assurez-vous que le fichier de sourçage correspond bien au releaseId indiqué.

# Régionalisation
<a name="CloudWatch-RUM-Regionalization"></a>

Cette section illustre les stratégies d'utilisation CloudWatch du RUM avec des applications dans différentes régions.

## Mon application est déployée dans plusieurs AWS régions
<a name="CloudWatch-RUM-Regionalization-multiple"></a>

Si votre application est déployée dans plusieurs AWS régions, trois options s'offrent à vous :
+ Déployez un moniteur d'application dans une seule région, dans un seul compte, qui sert toutes les régions.
+ Déployez des moniteurs d'application distincts pour chaque région, dans des comptes uniques.
+ Déployez des moniteurs d'application distincts pour chaque région, dans un seul compte.

L'avantage d'utiliser un seul moniteur d'application est que toutes les données seront centralisées dans une seule visualisation et que tous les journaux seront écrits dans le même groupe de CloudWatch journaux dans Logs. Avec un seul moniteur d'application, il y a une petite latence supplémentaire pour les requêtes et un point unique de défaillance.

L'utilisation de plusieurs moniteurs d'application élimine le point unique de défaillance, mais empêche la combinaison de toutes les données dans une seule visualisation.

### CloudWatch RUM n'a pas été lancé dans certaines régions dans lesquelles mon application est déployée
<a name="CloudWatch-RUM-Regionalization-notavailable"></a>

CloudWatch Le RUM est lancé dans de nombreuses régions et possède une large couverture géographique. En installant le CloudWatch RUM dans les régions où il est disponible, vous pouvez bénéficier des avantages. Les utilisateurs finaux peuvent se trouver n'importe où tout en ayant leurs sessions incluses si vous avez configuré un moniteur d'application dans la région à laquelle ils se connectent.

Cependant, le CloudWatch RUM n'est encore lancé dans aucune région de Chine. Vous n'êtes pas en mesure d'envoyer des données à CloudWatch RUM depuis ces régions.

# Utiliser des groupes de pages
<a name="CloudWatch-RUM-page-groups"></a>

Utilisez des groupes de pages pour associer différentes pages de votre application entre elles afin de pouvoir consulter des analyses agrégées pour des groupes de pages. Par exemple, vous souhaiterez peut-être voir les temps de chargement agrégés de toutes vos pages de destination. 

Vous placez les pages dans des groupes de pages en ajoutant une ou plusieurs balises aux événements d'affichage des pages dans le client Web CloudWatch RUM. Les exemples suivants placent la page `/home` dans le groupe de pages intitulé `en` et le groupe de pages intitulé `landing`.

**Exemple de script intégré**

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

**JavaScript exemple de module**

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

**Note**  
Les groupes de pages sont destinés à faciliter l'agrégation des analyses sur différentes pages. Pour plus d'informations sur la façon de définir et de manipuler `pageIds` pour votre application, consultez la section **Manually recording page views** dans [Modification de l'extrait de code pour configurer le client Web CloudWatch RUM (facultatif)](CloudWatch-RUM-modify-snippet.md).

# Spécifier des métadonnées personnalisées
<a name="CloudWatch-RUM-custom-metadata"></a>

CloudWatch RUM attache des données supplémentaires à chaque événement sous forme de métadonnées. Les métadonnées d'événement se composent d'attributs sous forme de paires clé-valeur. Vous pouvez utiliser ces attributs pour rechercher ou filtrer des événements dans la console CloudWatch RUM. Par défaut, CloudWatch RUM crée des métadonnées pour vous. Pour en savoir plus sur les métadonnées par défaut, consultez [Métadonnées des événements RUM](CloudWatch-RUM-datacollected.md#CloudWatch-RUM-datacollected-metadata).

Vous pouvez également utiliser le client Web CloudWatch RUM pour ajouter des métadonnées personnalisées aux événements CloudWatch RUM. Les métadonnées personnalisées peuvent inclure des attributs de session et des attributs de page.

Pour ajouter des métadonnées personnalisées, vous devez utiliser la version 1.10.0 ou ultérieure du client Web CloudWatch RUM.

## Exigences et syntaxe
<a name="CloudWatch-RUM-custom-metadata-syntax"></a>

Chaque événement peut inclure jusqu'à 10 attributs personnalisés dans les métadonnées. Les exigences syntaxiques pour les attributs personnalisés sont les suivantes :
+ **Clés**
  + 128 caractères maximum
  + Peut inclure des caractères alphanumériques, des deux-points (:) et des traits de soulignement (\$1)
  + Ne doit pas commencer par `aws:`.
  + Ne peut pas être entièrement constituée de l'un des mots-clés réservés énumérés dans la section suivante. Peut utiliser ces mots-clés dans le cadre d'un nom de clé plus long.
+ **Valeurs**
  + 256 caractères maximum
  + Doit être une chaîne de caractères, un nombre ou une valeur booléenne

**Mots-clés réservés**

Vous ne pouvez pas utiliser les mots-clés réservés suivants comme noms de clés complets. Vous pouvez utiliser les mots-clés suivants comme partie d'un nom de clé plus long, tel que `applicationVersion`.
+ `browserLanguage`
+ `browserName`
+ `browserVersion`
+ `countryCode`
+ `deviceType`
+ `domain`
+ `interaction`
+ `osName`
+ `osVersion`
+ `pageId`
+ `pageTags`
+ `pageTitle`
+ `pageUrl`
+ `parentPageId`
+ `platformType`
+ `referrerUrl`
+ `subdivisionCode`
+ `title`
+ `url`
+ `version`

**Note**  
CloudWatch RUM supprime les attributs personnalisés des événements RUM si un attribut inclut une clé ou une valeur non valide, ou si la limite de 10 attributs personnalisés par événement a déjà été atteinte. 

## Ajout d'un attribut de session
<a name="CloudWatch-RUM-session-attributes"></a>

Si vous configurez des attributs de session personnalisés, ils sont ajoutés à tous les événements d'une session. Vous configurez les attributs de session soit lors de l'initialisation du client Web CloudWatch RUM, soit lors de l'exécution à l'aide de la `addSessionAttributes` commande.

Par exemple, vous pouvez ajouter la version de votre application comme attribut de session. Ensuite, dans la console CloudWatch RUM, vous pouvez filtrer les erreurs par version afin de déterminer si un taux d'erreur accru est associé à une version particulière de votre application. 

**Ajout d'un attribut de session pendant l'initialisation, exemple NPM**

La section de code en gras ajoute l'attribut de session.

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

**Ajout d'un attribut de session au moment de l'exécution, exemple NPM**

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

**Ajout d'un attribut de session pendant l'initialisation, exemple de script intégré**

La section de code en gras ajoute l'attribut de session.

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

**Ajout d'un attribut de session au moment de l'exécution, exemple de script intégré**

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

## Ajout d'attributs de page
<a name="CloudWatch-RUM-page-attributes"></a>

Si vous configurez des attributs de page personnalisés, ils sont ajoutés à tous les événements de la page actuelle. Vous configurez les attributs de page soit lors de l'initialisation du client Web CloudWatch RUM, soit lors de l'exécution à l'aide de la `recordPageView` commande.

Par exemple, vous pouvez ajouter votre modèle de page comme attribut de page. Ensuite, dans la console CloudWatch RUM, vous pouvez filtrer les erreurs par modèles de page afin de déterminer si un taux d'erreur accru est associé à un modèle de page particulier de votre application. 

**Ajout d'un attribut de page pendant l'initialisation, exemple NPM**

La section de code en gras ajoute l'attribut de page.

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

**Ajout d'un attribut de page au moment de l'exécution, exemple NPM**

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

**Ajout d'un attribut de page pendant l'initialisation, exemple de script intégré**

La section de code en gras ajoute l'attribut de page.

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

**Ajout d'un attribut de page au moment de l'exécution, exemple de script intégré**

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

## Filtrage par attributs de métadonnées dans la console
<a name="CloudWatch-RUM-custom-attiributes-console"></a>

Pour filtrer les visualisations de la console CloudWatch RUM à l'aide d'un attribut de métadonnées intégré ou personnalisé, utilisez la barre de recherche. Dans la barre de recherche, vous pouvez spécifier jusqu'à 20 termes de filtre sous la forme **clé=valeur** à appliquer aux visualisations. Par exemple, pour filtrer les données concernant uniquement le navigateur Chrome, vous pouvez ajouter le terme de filtre **browserName=Chrome**.

Par défaut, la console CloudWatch RUM récupère les 100 clés et valeurs d'attributs les plus courants à afficher dans le menu déroulant de la barre de recherche. Pour ajouter d'autres attributs de métadonnées comme termes de filtre, saisissez la clé et la valeur complètes de l'attribut dans la barre de recherche. 

Un filtre peut inclure jusqu'à 20 termes de filtre, et vous pouvez enregistrer jusqu'à 20 filtres par moniteur d'application. Lorsque vous enregistrez un filtre, il est sauvegardé dans la liste déroulante **Saved filters** (Filtres enregistrés). Vous pouvez également supprimer un filtre enregistré. 

# Envoyer des événements personnalisés
<a name="CloudWatch-RUM-custom-events"></a>

CloudWatch RUM enregistre et ingère les événements listés dans[Informations collectées par le client Web CloudWatch RUM](CloudWatch-RUM-datacollected.md). Si vous utilisez la version 1.12.0 ou ultérieure du client Web CloudWatch RUM, vous pouvez définir, enregistrer et envoyer des événements personnalisés supplémentaires. Vous définissez le nom du type d'événement et les données à envoyer pour chaque type d'événement que vous définissez. Chaque charge utile d'événement personnalisé peut atteindre 6 Ko.

Les événements personnalisés sont ingérés uniquement si les événements personnalisés sont activés dans le moniteur d'applications. Pour mettre à jour les paramètres de configuration de votre moniteur d'applications, utilisez la console CloudWatch RUM ou l'[UpdateAppMonitor](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_UpdateAppMonitor.html)API. 

Après avoir activé les événements personnalisés, puis défini et envoyé des événements personnalisés, vous pouvez les rechercher. Pour les rechercher, utilisez l'onglet **Events** de la console CloudWatch RUM. Recherchez en utilisant le type d'événement.

## Exigences et syntaxe
<a name="CloudWatch-RUM-custom-event-syntax"></a>

Les événements personnalisés se composent d'un type d'événement et des détails de l'événement. Les conditions requises pour ces derniers sont les suivantes :
+ **Type d'événement**
  + Il peut s'agir du **type** ou du **nom** de votre événement. Par exemple, le type d'événement intégré CloudWatch RUM appelé **JsError**possède un type d'événement de`com.amazon.rum.js_error_event`.
  + Doit comporter entre 1 et 256 caractères.
  + Peut être une combinaison de caractères alphanumériques, de traits de soulignement, de tirets et de points.
+ **Détails de l'événement**
  + Contient les données réelles que vous souhaitez enregistrer dans CloudWatch RUM.
  + Doit être un objet qui se compose de champs et de valeurs.

## Exemples d'enregistrement d'événements personnalisés
<a name="CloudWatch-RUM-custom-event-examples"></a>

Il existe deux manières d'enregistrer des événements personnalisés dans le client Web CloudWatch RUM. 
+ Utilisez l'`recordEvent`API du client Web CloudWatch RUM.
+ Utilisez un plugin personnalisé.

**Envoyer un événement personnalisé à l'aide de l'API `recordEvent`, exemple NPM**

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

**Envoyer un événement personnalisé à l'aide de l'API `recordEvent`, exemple de script intégré**

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

**Exemple d'envoi d'un événement personnalisé à l'aide d'un plugin personnalisé**

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

# Consulter le tableau de bord CloudWatch du RUM
<a name="CloudWatch-RUM-view-data"></a>

CloudWatch RUM vous aide à collecter des données à partir des sessions utilisateur concernant les performances de votre application, notamment les temps de chargement, le score Apdex, les informations sur les appareils, la géolocalisation des sessions utilisateur et les sessions comportant des erreurs. Toutes ces informations sont affichées dans un tableau de bord.

Pour consulter le tableau de bord du RUM :

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

La console RUM affiche une liste de tous les moniteurs de vos applications. La colonne **Plateforme** indique si chaque moniteur d'applications est destiné aux applications Web, Android ou iOS. Sélectionnez un moniteur d'application pour accéder à des vues détaillées avec les onglets **Performances**, **Erreurs**, **Sessions**, **Mesures** et **Configuration**.

## Tableau de bord des applications Web
<a name="CloudWatch-RUM-web-dashboard"></a>

Lorsque vous sélectionnez un moniteur d'applications Web, les onglets suivants s'affichent :
+ L’onglet **Performances** affiche les informations sur les performances des pages, notamment les temps de chargement, les détails des requêtes, les indicateurs Web essentiels et l’évolution du nombre de chargements de page dans le temps. Cette vue comporte des graphiques interactifs sur lesquels vous pouvez voir les différentes valeurs percentiles des principaux éléments vitaux du Web pour vos pages et choisir des points de données sur le graphique pour afficher les événements associés capturés par RUM. CloudWatch À partir de cet endroit, vous pouvez explorer d’autres événements liés au pic de la métrique ou afficher les détails de la page associée à un événement sélectionné afin d’identifier les conditions précises à l’origine des problèmes de performance.

  Dans cet onglet, vous pouvez également basculer l’affichage entre **Chargements de page**, **Requêtes** et **Emplacement** pour obtenir davantage de détails sur les performances des pages.
+ L'onglet **Erreurs** affiche des informations sur les erreurs Javascript, y compris le message d'erreur le plus fréquemment vu par les utilisateurs et les appareils, ainsi que les navigateurs présentant le plus d'erreurs. Cette vue inclut un histogramme des erreurs et une liste des erreurs. Vous pouvez filtrer la liste des erreurs par utilisateur et par événement. Choisissez un message d'erreur pour obtenir plus de détails.
+ L'onglet **Requêtes HTTP** affiche les informations relatives aux requêtes HTTP, notamment l'URL de la requête comportant le plus d'erreurs et les appareils et navigateurs présentant le plus grand nombre d'erreurs. Cet onglet inclut un histogramme des requêtes, une liste des requêtes et une liste des erreurs réseau. Vous pouvez filtrer les listes par utilisateur et par événement. Choisissez un code de réponse ou un message d'erreur pour obtenir plus de détails sur la demande ou l'erreur réseau, respectivement.
+ L'onglet **Sessions** affiche les métriques de session. Cet onglet inclut un histogramme des événements de démarrage de session et une liste des sessions. Vous pouvez filtrer la liste des sessions par type d'événement, informations sur l'utilisateur et détails de l'événement. Choisissez une **sessionId** pour obtenir plus de détails sur une session.
+ L'onglet **Événements** affiche un histogramme des événements RUM et une liste des événements. Vous pouvez filtrer la liste des événements par type d'événement, informations sur l'utilisateur et détails de l'événement. Choisissez un événement RUM pour voir l'événement brut.
+ L'onglet **Browsers & Devices** (Navigateurs et appareils) affiche des informations telles que la performance et l'utilisation de différents navigateurs et appareils utilisés pour accéder à votre application. Cette vue comprend des commandes permettant de basculer la vue pour mettre en évidence les éléments **Navigateurs** et **Appareils**.

  Si vous limitez la portée à un seul navigateur, les données sont réparties par version du navigateur.
+ L'onglet **User Journey** (Parcours utilisateur) affiche les chemins que vos clients utilisent pour parcourir votre application. Vous pouvez voir où vos clients entrent dans votre application et de quelle page ils la quittent. Vous pouvez également voir les chemins qu'ils empruntent et le pourcentage de clients qui suivent ces chemins. Vous pouvez faire une pause sur un nœud pour obtenir plus de détails sur la page concernée. Vous pouvez choisir un chemin spécifique pour mettre en évidence les connexions et faciliter la visualisation.
+  L'onglet **Mesures** affiche toutes les CloudWatch mesures par défaut publiées par le moniteur de votre application, notamment les indicateurs de performance Web, les indicateurs d'erreur (JavaScript erreurs, erreurs/défauts HTTP), le volume, le flux d'utilisateurs et les indicateurs apdex. Si vous avez créé des métriques étendues pour votre application, l'onglet inclut également un sous-ensemble de ces métriques dans la section des métriques étendues. Ce sous-ensemble inclut les métriques de type PageViewCount, Http4xxCount PerformanceNavigationDuration, Http5xxCount et. JsErrorCount Le tableau de bord affiche trois variations métriques par type de métrique. Comme il s'agit de CloudWatch statistiques, vous pouvez également exporter cet onglet vers votre propre tableau de bord à l'aide de l'option **Ajouter au tableau de bord** et le mettre à jour pour inclure d'autres mesures. 

(Facultatif) Sur n'importe lequel des six onglets, vous pouvez choisir le bouton **Pages** et sélectionner une page ou un groupe de pages dans la liste. Cela permet de n'afficher les données que d'une seule page ou d'un seul groupe de pages de votre application. Vous pouvez également marquer les pages et groupes de pages de la liste comme favoris.

## Tableau de bord des applications mobiles
<a name="CloudWatch-RUM-mobile-dashboard"></a>

Lorsque vous sélectionnez un moniteur d'application mobile, les onglets suivants s'affichent :
+ L'onglet **Performances** fournit des informations sur les performances de votre application mobile, notamment les temps de chargement de l'écran, les temps de lancement des applications (froid et chaud), les indicateurs de performance et les scores Apdex au fil du temps. La vue détaillée ventile les performances par nom d'écran, version du système d'exploitation, version de l'application, appareil et pays. **Cliquez sur le temps de chargement de l'écran, l'heure de lancement de l'application ou un point de données de localisation dans le graphique pour ouvrir le panneau de diagnostic sur la droite qui fournit des informations supplémentaires relatives au point de données constitué des sessions corrélées les plus récentes et des liens vers l'onglet Sessions pour le dépannage.**

  Dans cet onglet, vous pouvez également basculer entre les affichages **d'écran**, les **lancements d'applications** et la **localisation** pour obtenir plus de détails sur les performances des applications.

  L'onglet présente également le score de l'indice de performance des applications (Apdex) qui indique le niveau de satisfaction des utilisateurs finaux. Les scores vont de 0 (satisfaction minimale) à 1 (satisfaction maximale). Les scores sont basés uniquement sur la performance de l'application. Pour plus d'informations sur les scores Apdex, consultez [Comment CloudWatch RUM définit les scores d'Apdex](#CloudWatch-RUM-apdex).
+ L'onglet **Erreurs** classe les problèmes liés aux applications en trois catégories : erreurs réseau, pannes et blocages ANRs (Android) /applications (iOS). L'onglet **Erreurs réseau** comporte un graphique linéaire indiquant la latence du réseau, les erreurs du client (code d'état 4xx) et les erreurs du serveur (code d'état 5xx). Cliquez sur un point de données pour l'une de ces lignes du graphique pour ouvrir le panneau de diagnostic. Le tableau du bas répertorie les 100 itinéraires réseau les plus courants. En cliquant sur un bouton radio, le graphique linéaire sera filtré en fonction de l'itinéraire réseau sélectionné.

  De même, les onglets **Crashes** et **ANRs/App Hangs** affichent une série de lignes indiquant le nombre de chaque erreur, et celles-ci sont difficiles à résoudre. Le tableau inférieur affiche le message de crash supérieur ou la trace de ANR/App Hang Stack le plus courant. Cliquez sur un bouton radio pour filtrer le graphique, et cliquez sur le message d'erreur pour afficher la trace complète de la pile.
+ L'onglet **Sessions** affiche un tableau répertoriant toutes les sessions par ordre chronologique décroissant. En bas, une visualisation en cascade montre toute la télémétrie de la session sélectionnée, vous aidant à suivre les interactions des utilisateurs et à identifier les problèmes de performance. Chaque ligne de la cascade peut être sélectionnée pour ouvrir le panneau de diagnostic. Pour les requêtes HTTP, vous verrez un **TraceID** qui renvoie à la console Traces.

  Pour les requêtes HTTP avec des codes d'état autres que 2xx, des pannes ou des blocages d'applications ANRs (Android) ou des blocages d'applications (iOS), le panneau de diagnostic inclut **un** onglet Exception avec la trace de la pile. Le bouton **Afficher** situé dans la cascade permet d'accéder rapidement à ces informations.
+ L'onglet **Mesures** affiche toutes les CloudWatch mesures par défaut publiées par le moniteur de votre application, y compris les mesures de performance (temps de chargement de l'écran, temps de lancement des applications à froid), les mesures d'erreur ( ANRs/App crashs, blocageserrors/faults), volume and apdex metrics. If you created extended metrics for your application, the tab also includes a subset of these metrics in the extended metrics section. This subset includes metrics of type ScreenLoadTime, ScreenLoadCount, CrashCount, Http4xxCount, Http5xxCount, ANRCount/AppHangCount, ColdLaunchTime HTTP et. WarmLaunchTime Le tableau de bord affiche trois variations métriques par type de métrique. Comme il s'agit de CloudWatch statistiques, vous pouvez également exporter cet onglet vers votre propre tableau de bord à l'aide de l'option **Ajouter au tableau de bord** et le mettre à jour pour inclure d'autres mesures.
+ L'onglet **Configuration** permet d'accéder aux paramètres généraux et aux détails de configuration de votre moniteur d'applications. Vous pouvez également accéder à l'onglet **Extraits de code** qui contient des instructions pour instrumenter votre application mobile avec le SDK ADOT, y compris les options d'instrumentation manuelle et zéro code.

### Comment CloudWatch RUM définit les scores d'Apdex
<a name="CloudWatch-RUM-apdex"></a>

Apdex (Application Performance Index) est une norme ouverte qui définit une méthode pour comparer et évaluer le temps de réponse des applications et générer des rapports sur celui-ci. Un score Apdex vous aide à comprendre et à identifier l'impact sur la performance de l'application au fil du temps.

Le score Apdex indique le niveau de satisfaction des utilisateurs finaux. Les scores vont de 0 (satisfaction minimale) à 1 (satisfaction maximale). Les scores sont basés uniquement sur la performance de l'application. Les utilisateurs ne sont pas invités à évaluer l'application.

Chaque score Apdex individuel se trouve dans l'un des trois seuils. En fonction du seuil Apdex et du temps de réponse réel de l'application, il existe trois types de performances, à savoir :
+ **Satisfait** — Le temps de réponse réel de l'application est inférieur ou égal au seuil Apdex. Pour le CloudWatch RUM, ce seuil est inférieur ou égal à 2000 ms.
+ **Tolérable** — Le temps de réponse réel de l'application est supérieur au seuil Apdex, mais inférieur ou égal à quatre fois le seuil Apdex. Pour le CloudWatch RUM, cette plage est comprise entre 2 000 et 8 000 ms.
+ **Frustrant** — Le temps de réponse réel de l'application est supérieur à quatre fois le seuil Apdex. Pour le CloudWatch RUM, cette plage est supérieure à 8 000 ms.

Le score Apdex total, compris entre 0 et 1, est calculé à l'aide de la formule suivante :

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

# CloudWatch métriques que vous pouvez collecter avec CloudWatch RUM
<a name="CloudWatch-RUM-metrics"></a>

Les tableaux de cette section répertorient les métriques que vous collectez automatiquement avec CloudWatch RUM à partir d'applications Web, d'applications mobiles ou des deux. Vous pouvez consulter ces statistiques dans la CloudWatch console. Pour de plus amples informations, veuillez consulter [Affichage des métriques disponibles](viewing_metrics_with_cloudwatch.md).

Vous pouvez également éventuellement envoyer des métriques étendues à CloudWatch. Pour de plus amples informations, veuillez consulter [Métriques étendues](CloudWatch-RUM-custom-and-extended-metrics.md#CloudWatch-RUM-vended-metrics).

Ces métriques sont publiées dans l'espace de noms de métrique nommé `AWS/RUM`. Les métriques suivantes sont publiées avec la dimension `application_name`. La valeur de cette dimension est le nom du moniteur d'application. Certaines mesures sont également publiées avec des dimensions supplémentaires, comme indiqué dans le tableau suivant.


**Métriques Web**  

| Métrique | Unité | Description | 
| --- | --- | --- | 
|  `HttpStatusCodeCount` |  Nombre  |  Le nombre de réponses HTTP dans l'application, en fonction de leur code d'état de réponse. Dimensions supplémentaires : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `Http4xxCount` |  Nombre  |  Nombre de réponses HTTP dans l’application avec un code d’état 4xx. Ce nombre est calculé à partir des événements RUM `http_event` ayant généré des codes 4xx.  | 
|  `Http4xxCountPerSession` |  Nombre  |  Nombre de réponses HTTP dans une session avec un code d’état 4xx. Ce nombre est calculé à partir des événements RUM `http_event` ayant généré des codes 4xx.  | 
|  `Http4xxCountPerPageView` |  Nombre  |  Nombre de réponses HTTP lors d’une visualisation de page avec un code d’état 4xx. Ce nombre est calculé à partir des événements RUM `http_event` ayant généré des codes 4xx.  | 
|  `Http5xxCount` |  Nombre  |  Nombre de réponses HTTP dans l’application avec un code d’état 5xx. Ce nombre est calculé à partir des événements RUM `http_event` ayant généré des codes 5xx.  | 
|  `Http5xxCountPerSession` |  Nombre  |  Nombre de réponses HTTP dans la session avec un code d’état 5xx. Ce nombre est calculé à partir des événements RUM `http_event` ayant généré des codes 5xx.  | 
|  `Http5xxCountPerPageView` |  Nombre  |  Nombre de réponses HTTP lors d’une visualisation de page avec un code d’état 5xx. Ce nombre est calculé à partir des événements RUM `http_event` ayant généré des codes 5xx.  | 
|  `JsErrorCount` |  Nombre  |  Nombre d'événements d' JavaScript erreur ingérés.   | 
|  `JsErrorCountPerSession` |  Nombre  |  Nombre d'événements d' JavaScript erreur ingérés au cours d'une session.  | 
|  `JsErrorCountPerPageView` |  Nombre  |  Nombre d'événements d' JavaScript erreur ingérés lors de la révision d'une page.  | 
|  `NavigationFrustratedTransaction` |  Nombre  |  Le nombre d'événements de navigation avec une `duration` plus élevée que le seuil de tolérance, qui est de 8000 ms. La durée des événements de navigation est comptabilisée dans la métrique `PerformanceNavigationDuration`.  | 
|  `NavigationSatisfiedTransaction` |  Nombre  |  Le nombre d'événements de navigation avec une `duration` inférieure à l'objectif Apdex, qui est de 2000 ms. La durée des événements de navigation est comptabilisée dans la métrique `PerformanceNavigationDuration`.  | 
|  `NavigationToleratedTransaction` |  Nombre  |  Le nombre d'événements de navigation avec une `duration` comprise entre 2000 ms et 8000 ms. La durée des événements de navigation est comptabilisée dans la métrique `PerformanceNavigationDuration`.  | 
|  `PageViewCount` |  Nombre  |  Nombre d’événements de visualisation de page ingérés par le moniteur d’application. Ce nombre est calculé en comptant les événements RUM `page_view_event`.  | 
|  `PageViewCountPerSession` |  Nombre  |  Nombre d’événements de visualisation de page dans une session. | 
|  `PerformanceResourceDuration` |  Millisecondes  |  La `duration` d'un événement de ressources. Dimensions supplémentaires : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `PerformanceNavigationDuration` |  Millisecondes  |  La `duration` d'un événement de navigation.  | 
|  `RumEventPayloadSize` |  Octets  |  La taille de chaque événement ingéré par CloudWatch RUM. Vous pouvez également utiliser la statistique `SampleCount` de cette métrique afin de surveiller le nombre d'événements qu'un moniteur d'application ingère.  | 
|  `SessionCount` |  Nombre  |  Le nombre d'événements de démarrage de session ingérés par le moniteur d'application. En d'autres termes, le nombre de nouvelles sessions démarrées.  | 
|  `SessionDuration` |  Millisecondes  |  Durée d’une session. Cette durée est calculée à partir du temps écoulé entre le premier et le dernier événement de la session.  | 
|  `TimeOnPage` |  Millisecondes  |  Durée d’une visualisation de page. Cette durée est calculée jusqu’à la visualisation de la page suivante, sauf pour la dernière page d’une session, où elle correspond au temps écoulé entre le premier et le dernier événement sur cette page.  | 
|  `WebVitalsCumulativeLayoutShift` |  Aucune  |  Effectue le suivi de la valeur des événements Cumulative Layout Shift.  | 
|  `WebVitalsFirstInputDelay` |  Millisecondes  |  Effectue le suivi de la valeur des événements First Input Delay.  | 
|  `WebVitalsLargestContentfulPaint` |  Millisecondes  |  Effectue le suivi de la valeur des événements Largest Contentful Paint.  | 
|  `WebVitalsInteractionToNextPaint` |  Millisecondes  |  Valeur des événements d’interaction jusqu’au prochain rendu visuel.  | 

Vous pouvez configurer des métriques étendues pour votre application mobile afin de fournir des dimensions supplémentaires pour l'analyse.


**Métriques mobiles**  

| Métrique | Unité | Description | 
| --- | --- | --- | 
|  `ANRCount`  |  Nombre  |  Pour Android uniquement : le nombre d'incidents ANR (Application Not Responding) survenant lorsque l'application ne répond pas pendant plus de 5 secondes, entraînant un blocage de l'application.  | 
|  `AppHangCount`  |  Nombre  |  Pour iOS uniquement : nombre de fois où l'application n'a pas répondu pendant plus de 250 ms sur la boucle principale.  | 
|  `ColdAppLaunchFrustratedTransaction`  |  Nombre  |  Le nombre de lancements d'applications à froid qui ont pris plus de 8 secondes, ce qui a probablement causé de la frustration chez les utilisateurs.  | 
|  `ColdAppLaunchSatisfiedTransaction`  |  Nombre  |  Le nombre de lancements d'applications à froid effectués en moins de 2 secondes, offrant une expérience utilisateur satisfaisante.  | 
|  `ColdAppLaunchToleratedTransaction`  |  Nombre  |  Le nombre de lancements d'applications à froid qui se sont déroulés entre 2 et 8 secondes, offrant une expérience utilisateur tolérable, mais pas idéale.  | 
|  `ColdLaunchTime`  |  Millisecondes  |  Temps nécessaire pour lancer l'application à partir d'un état terminé. Pour Android : délai entre l'application et la `onCreate` fin de la création de la première activité. Pour iOS : temps écoulé entre le démarrage de l'application (déterminé par la commande de démarrage `sysctl` du processus) et`didBecomeActiveNotification`.  | 
|  `CrashCount`  |  Nombre  |  Le nombre de fermetures inattendues d'applications causées par des exceptions non gérées ou par la fermeture du système d'exploitation. Pour Android : pannes dues à des exceptions non gérées ou à l'arrêt du système. Pour iOS : pannes dues à des exceptions non gérées, à des erreurs fatales ou à l'arrêt du système. Les données de crash sont stockées localement et signalées lors du prochain lancement de l'application.  | 
|  `DroppedEventsCount`  |  Nombre  |  Le nombre d'événements du journal qui ont été supprimés parce qu'ils dépassaient la limite de taille maximale de 30 Ko par événement.  | 
|  `DroppedSpansCount`  |  Nombre  |  Nombre de spans supprimés parce qu'ils dépassaient la limite de taille maximale de 30 Ko par intervalle.  | 
|  `Http4xxCount`  |  Nombre  |  Enregistre le nombre d'erreurs client HTTP rencontrées par le Web ou l'application mobile lors de requêtes HTTP.  | 
|  `Http5xxCount`  |  Nombre  |  Enregistre le nombre d'erreurs de serveur HTTP rencontrées par le Web ou l'application mobile lors de requêtes HTTP.  | 
|  `LogPayloadSize`  |  Octets  |  Taille en octets des données de télémétrie du journal envoyées à CloudWatch RUM. Vous pouvez également utiliser les `SampleCount` statistiques de cette métrique pour surveiller le nombre d'événements de journal ingérés par un moniteur d'application.  | 
|  `NetworkLatency`  |  Millisecondes  |  Le temps nécessaire au traitement des demandes réseau, qui mesure le temps aller-retour entre le lancement de la demande et la fin de la réponse.  | 
|  `ScreenLoadCount`  |  Nombre  |  Le nombre total de chargements d'écran.  | 
|  `ScreenLoadToleratedTransaction`  |  Nombre  |  Le nombre de chargements d'écran effectués entre 2 et 8 secondes, offrant une expérience utilisateur tolérable, mais pas idéale.  | 
|  `SessionCount`  |  Nombre  |  Nombre total de sessions utilisateur uniques avec l'application. Une session commence lorsque l'utilisateur ouvre l'application et se termine après 30 minutes d'inactivité ou lorsqu'elle est explicitement interrompue.  | 
|  `SpanPayloadSize`  |  Octets  |  Taille en octets des données de télémétrie span envoyées au CloudWatch RUM. Vous pouvez également utiliser les `SampleCount` statistiques de cette métrique pour surveiller le nombre de Spans ingérés par un moniteur d'applications.  | 
|  `WarmAppLaunchFrustratedTransaction`  |  Nombre  |  Le nombre de lancements d'applications en cours qui ont pris plus de 8 secondes, ce qui a probablement causé de la frustration chez les utilisateurs.  | 
|  `WarmAppLaunchSatisfiedTransaction`  |  Nombre  |  Le nombre de lancements d'applications Warm terminés en moins de 2 secondes, offrant une expérience utilisateur satisfaisante.  | 
|  `WarmAppLaunchToleratedTransaction`  |  Nombre  |  Le nombre de lancements d'applications en cours qui se sont déroulés entre 2 et 8 secondes, offrant une expérience utilisateur tolérable, mais pas idéale.  | 
|  `WarmLaunchTime`  |  Millisecondes  |  Temps nécessaire au lancement de l'application depuis l'état d'arrière-plan. Pour Android : délai entre l'application et la `onCreate` fin de la création de la première activité. Pour iOS : temps écoulé entre le moment et le `UIApplicationWillEnterForegroundNotification` moment où`didBecomeActiveNotification`.  | 

# Métriques personnalisées et métriques étendues que vous pouvez envoyer à CloudWatch
<a name="CloudWatch-RUM-custom-and-extended-metrics"></a>

Par défaut, les moniteurs de l'application RUM envoient des métriques à CloudWatch. Ces mesures et dimensions par défaut sont répertoriées dans [CloudWatch les métriques que vous pouvez collecter avec CloudWatch RUM](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html).

Vous pouvez également configurer un moniteur d’application pour exporter des métriques. Le moniteur d’application peut envoyer des métriques étendues, des métriques personnalisées ou les deux. Il peut les envoyer à CloudWatch.
+ **Métriques personnalisées** : les métriques personnalisées sont des métriques que vous définissez. Avec les métriques personnalisées, vous pouvez utiliser n'importe quel nom de métrique et n'importe quel espace de noms. Pour obtenir les métriques, vous pouvez utiliser des événements personnalisés, des événements intégrés, des attributs personnalisés ou des attributs par défaut.

  Vous pouvez envoyer des métriques personnalisées à CloudWatch.
+ **Métriques étendues** — Vous pouvez envoyer n'importe laquelle des métriques CloudWatch RUM par défaut CloudWatch avec des dimensions supplémentaires. De cette façon, ces métriques peuvent donner une vue plus fine.

**Topics**
+ [Métriques personnalisées](#CloudWatch-RUM-custom-metrics)
+ [Métriques étendues](#CloudWatch-RUM-vended-metrics)

## Métriques personnalisées
<a name="CloudWatch-RUM-custom-metrics"></a>

Pour envoyer des métriques personnalisées, vous devez utiliser le AWS APIs ou à la AWS CLI place de la console. Pour plus d'informations sur l'utilisation du AWS APIs, reportez-vous [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html)aux sections et [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

Le nombre maximum de définitions de métriques étendues et de métriques personnalisées qu'une destination peut contenir est de 2 000. Pour chaque métrique personnalisée ou étendue que vous envoyez à chaque destination, chaque combinaison de nom de dimension et de valeur de dimension est prise en compte dans cette limite. Vous n'êtes pas facturé pour les métriques personnalisées dérivées de tout type d'événements ou d'attributs du CloudWatch RUM.

L'exemple suivant montre comment créer une métrique personnalisée dérivée d'un événement personnalisé. Voici l'exemple d'événement personnalisé utilisé :

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

Compte tenu de cet événement personnalisé, vous pouvez créer une métrique personnalisée qui compte le nombre de visites sur l'URL `amazonaws.com` depuis des navigateurs Chrome. La définition suivante crée une métrique nommée `AmazonVisitsCount` dans votre compte, dans l'espace de noms `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étriques étendues
<a name="CloudWatch-RUM-vended-metrics"></a>

Si vous configurez des métriques étendues, vous pouvez envoyer n'importe laquelle des métriques CloudWatch RUM par défaut CloudWatch avec des dimensions supplémentaires afin que les métriques vous offrent une vue plus précise.

Pour plus d'informations sur les métriques CloudWatch RUM par défaut, consultez[CloudWatch métriques que vous pouvez collecter avec CloudWatch RUM](CloudWatch-RUM-metrics.md).

Le nombre maximum de définitions de métriques étendues et de métriques personnalisées qu'une destination peut contenir est de 2 000. Pour chaque métrique étendue ou personnalisée que vous envoyez à chaque destination, chaque combinaison de nom de dimension et de valeur de dimension compte comme une métrique étendue pour cette limite.

Lorsque vous envoyez des métriques étendues à CloudWatch, vous pouvez utiliser la console CloudWatch RUM pour créer des CloudWatch alarmes sur celles-ci.

Les métriques étendues créées pour les métriques par défaut de CloudWatch RUM ne vous sont pas facturées.

### Métriques étendues des applications Web
<a name="CloudWatch-RUM-web-extended-metrics"></a>

Les dimensions suivantes sont prises en charge pour les métriques étendues des applications Web :
+ `BrowserName`

  Exemples de valeurs de dimension : `Chrome`, `Firefox`, `Chrome Headless`
+ `CountryCode` Ceci utilise le format ISO-3166, avec des codes à deux lettres.

  Exemples de valeurs de dimension : `US`, `JP`, `DE`
+ `DeviceType`

  Exemples de valeurs de dimension : `desktop`, `mobile`, `tablet`, `embedded`
+ `FileType`

  Exemples de valeurs de dimension : `Image`, `Stylesheet`
+ `OSName`

  Exemples de valeurs de dimension : `Linux`, `Windows`, `iOS`, `Android`
+ `PageId`

### Métriques étendues des applications mobiles
<a name="CloudWatch-RUM-mobile-extended-metrics"></a>

Les dimensions suivantes sont prises en charge pour les métriques étendues des applications mobiles :
+ `ScreenName`
  + Valeur issue de l'attribut de nom d'écran - `attributes.screen.name` de votre application
  + Exemples de valeurs : HomeScreen SettingsView, ProfilePage
+ `DeviceModel`
  + Valeur issue de l'attribut du modèle d'appareil - `resource.attributes.device.model.name`
  + Exemples de valeurs : iPhone14,3, SM-G998B
+ `OSVersion`
  + Valeur provenant de l'attribut de version du système d'exploitation - `resource.attributes.os.version`
  + Exemples de valeurs : 16,0, 13,0

**Note**  
Mesures par défaut actuellement prises en charge pour les applications mobiles : `ScreenLoadTime` `ScreenLoadCount``NetworkLatency`,`Http4xxCount`,`Http5xxCount`,`CrashCount`,`ANRCount`,`AppHangCount`,`ColdLaunchTime`,`WarmLaunchTime`,,`SessionCount`, `SpanPayloadSize` et`LogPayloadSize`.

### Configuration des métriques étendues à l'aide de la console
<a name="CloudWatch-RUM-extended-metrics-console"></a>

Pour utiliser la console pour envoyer des métriques étendues à CloudWatch, procédez comme suit.

Pour plus d'informations sur l'utilisation du AWS APIs pour envoyer des métriques étendues à l'un ou l'autre CloudWatch, reportez-vous aux [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html)sections et [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

**Pour utiliser la console pour configurer un moniteur d'applications et envoyer des métriques étendues RUM à CloudWatch**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez le nom du moniteur d'application qui doit envoyer les métriques.

1. Choisissez l'onglet **Configuration**, puis **RUM extended metrics** (Métriques étendues RUM).

1. Choisissez **Send metrics** (Envoyer les métriques).

1. Sélectionnez un ou plusieurs noms de métriques à envoyer avec des dimensions supplémentaires.

1. Sélectionnez un ou plusieurs facteurs à utiliser comme dimensions pour ces métriques. Au fur et à mesure que vous faites vos choix, le nombre de métriques étendues que vos choix créent s'affiche dans **Number of extended metrics** (Nombre de métriques étendues).

   Ce nombre est calculé en multipliant le nombre de noms de métriques choisis par le nombre de dimensions différentes que vous créez.

   1. Pour envoyer une métrique avec l'ID de page comme dimension, choisissez **Rechercher l'ID de page**, puis sélectionnez la page IDs à utiliser.

   1. Pour envoyer une métrique avec le type d'appareil comme dimension, choisissez soit **Desktop devices** (Appareils de bureau), soit **Mobile and tablets** (Mobiles et tablettes).

   1. Pour envoyer une métrique avec le système d'exploitation comme dimension, sélectionnez un ou plusieurs systèmes d'exploitation sous **Operating system** (Système d'exploitation).

   1. Pour envoyer une métrique avec le type de navigateur comme dimension, sélectionnez un ou plusieurs navigateurs sous **Browsers** (Navigateurs).

   1. Pour envoyer une métrique avec la géolocalisation comme dimension, sélectionnez un ou plusieurs emplacements sous **Locations** (Emplacements).

      Seuls les emplacements dans lesquels ce moniteur d'application a enregistré des métriques apparaîtront dans la liste de choix.

1. Lorsque vous avez terminé vos choix, sélectionnez **Send metrics** (Envoyer les métriques).

1. (Facultatif) Dans la liste **Extended metrics** (Métriques étendues), pour créer une alarme qui surveille l'une des métriques, choisissez **Create alarm** (Créer une alarme) dans la ligne de cette métrique.

   Pour des informations générales sur les CloudWatch alarmes, consultez[Utilisation des CloudWatch alarmes Amazon](CloudWatch_Alarms.md). Pour un didacticiel sur le réglage d'une alarme sur une métrique étendue CloudWatch RUM, voir[Tutoriel : créer une métrique étendue et la déclencher](#CloudWatch-RUM-extended-metrics-alarmtutorial).

**Arrêt de l'envoi de métriques étendues**

**Pour utiliser la console pour arrêter l'envoi de métriques étendues**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez le nom du moniteur d'application qui doit envoyer les métriques.

1. Choisissez l'onglet **Configuration**, puis **RUM extended metrics** (Métriques étendues RUM).

1. Sélectionnez une ou plusieurs combinaisons de noms et de dimensions de métriques à arrêter d'envoyer. Puis, choisissez **Actions**, **Delete** (Supprimer).

### Tutoriel : créer une métrique étendue et la déclencher
<a name="CloudWatch-RUM-extended-metrics-alarmtutorial"></a>

Ce didacticiel explique comment configurer une métrique étendue à envoyer CloudWatch, puis comment définir une alarme sur cette métrique. Dans ce didacticiel, vous allez créer une métrique qui permet de suivre JavaScript les erreurs dans le navigateur Chrome.

**Pour configurer cette métrique étendue et définir une alarme sur celle-ci**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez le nom du moniteur d'application qui doit envoyer la métrique.

1. Choisissez l'onglet **Configuration**, puis **RUM extended metrics** (Métriques étendues RUM).

1. Choisissez **Send metrics** (Envoyer les métriques).

1. Sélectionnez **JSErrorCompter**.

1. Sous **Browsers** (Navigateurs), sélectionnez **Chrome**.

   Cette combinaison de **JSErrorCount** et **Chrome** enverra une métrique étendue à CloudWatch. La métrique compte JavaScript les erreurs uniquement pour les sessions utilisateur utilisant le navigateur Chrome. Le nom de la métrique sera **JsErrorCount**et le nom de la dimension sera **Browser**.

1. Choisissez **Send metrics** (Envoyer les métriques).

1. Dans la liste des **métriques étendues**, choisissez **Créer une alarme** dans la ligne qui s'affiche **JsErrorCount**sous **Nom** et **Chrome** sous **BrowserName**.

1. Sous **Spécifier la métrique et les conditions**, vérifiez que le **nom de la métrique** et **BrowserName**les champs sont préremplis avec les valeurs correctes.

1. Pour **Statistic** (Statistique), sélectionnez la statistique que vous voulez utiliser pour l'alarme. **Average** (Moyenne) est un bon choix pour ce type de métrique de comptage.

1. Pour **Période**, sélectionnez **5 minutes**.

1. Sous **Conditions**, procédez comme suit :
   + Choisissez **Static**.
   + Choisissez **Greater** (Supérieur) pour spécifier que l'alarme doit passer à l'état ALARM lorsque le nombre d'erreurs est supérieur au seuil que vous allez spécifier.
   + Sous **than...** (à…), saisissez le nombre correspondant au seuil d'alarme. L'alarme passe à l'état ALARM lorsque le nombre d'erreurs sur une période de 5 minutes dépasse ce nombre.

1. (Facultatif) Par défaut, l'alarme passe à l'état ALARM dès que le nombre d'erreurs dépasse le nombre seuil que vous avez défini pendant une période de 5 minutes. Vous pouvez, en option, modifier ce paramètre pour que l'alarme ne passe à l'état ALARM que si ce nombre est dépassé pendant plus d'une période de 5 minutes.

   Pour ce faire, sélectionnez **Additional configuration** (Configuration supplémentaire), puis pour **Datapoints to alarm** (Points de données à déclencher), indiquez le nombre de périodes de 5 minutes pendant lesquelles le nombre d'erreurs doit dépasser le seuil pour déclencher l'alarme. Par exemple, vous pouvez sélectionner 2 sur 2 pour que l'alarme se déclenche uniquement lorsque deux périodes de 5 minutes consécutives dépassent le seuil, ou 2 sur 3 pour que l'alarme se déclenche si deux des trois périodes de 5 minutes consécutives dépassent le seuil. 

   Pour plus d'informations sur ce type d'évaluation d'alarme, consultez [Évaluation des alarmes](alarm-evaluation.md).

1. Choisissez **Suivant**.

1. Pour **Configure actions** (Configurer les actions), indiquez ce qui doit se passer lorsque l'alarme passe à l'état d'alarme. Pour recevoir une notification avec Amazon SNS, procédez comme suit :
   + Sélectionnez **Ajouter une notification**.
   + Choisissez **En alarme**.
   + Sélectionnez une rubrique SNS existante ou créez-en une nouvelle. Si vous en créez un nouveau, indiquez-lui un nom et ajoutez-lui au moins une adresse e-mail.

1. Choisissez **Suivant**.

1. Saisissez un nom et une description facultative pour l'alarme, puis sélectionnez **Next** (Suivant).

1. Passez en revue les détails et sélectionnez **Create alarm** (Créer l'alarme).

# Protection et confidentialité des données avec CloudWatch RUM
<a name="CloudWatch-RUM-privacy"></a>

Le [modèle de responsabilité AWS partagée](https://aws.amazon.com/compliance/shared-responsibility-model/) s'applique à la protection et à la confidentialité des données dans Amazon CloudWatch RUM. Comme décrit dans ce modèle, AWS est responsable de la protection de l'infrastructure globale qui gère l'ensemble du AWS cloud. La gestion du contrôle de votre contenu hébergé sur cette infrastructure relève de votre responsabilité. Pour plus d'informations sur la confidentialité des données, consultez la [FAQ sur la confidentialité des données](https://aws.amazon.com/compliance/data-privacy-faq/). Pour plus d'informations sur la protection des données en Europe, consultez [le modèle de responsabilité AWS partagée et le billet de blog sur le RGPD](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) sur le blog sur la AWS sécurité. Pour plus de ressources relatives à la conformité aux exigences du RGPD, consultez le [Centre du Règlement général sur la protection des données (RGPD)](https://aws.amazon.com/compliance/gdpr-center/).

Amazon CloudWatch RUM génère un extrait de code que vous pouvez intégrer dans le code de votre site Web ou de votre application Web, en fonction des données d'utilisateur final que vous souhaitez collecter. Le client web, téléchargé et configuré par l'extrait de code, utilise des cookies (ou des technologies semblables) pour vous aider à collecter les données des utilisateurs finaux. L'utilisation de cookies (ou de technologies semblables) est soumise aux réglementations en matière de confidentialité des données dans certaines juridictions. Avant d'utiliser Amazon CloudWatch RUM, nous vous recommandons vivement d'évaluer vos obligations de conformité conformément à la législation en vigueur, y compris les exigences légales applicables, afin de fournir des avis de confidentialité juridiquement adéquats et d'obtenir les consentements nécessaires à l'utilisation de cookies et au traitement (y compris la collecte) des données des utilisateurs finaux. Pour plus d’informations sur l’utilisation des cookies (ou technologies similaires) par le client web CloudWatch RUM et sur les données collectées auprès des utilisateurs finaux, consultez [Informations collectées par le client Web CloudWatch RUM](CloudWatch-RUM-datacollected.md) et [CloudWatch Cookies du client Web RUM (ou technologies similaires)](#CloudWatch-RUM-cookies).

Nous vous recommandons vivement de ne jamais placer d'informations d'identification sensibles, telles que les numéros de compte, les adresses e-mail ou toute autre information personnelle de vos utilisateurs finaux, dans des champs à structure libre. Toutes les données que vous entrez dans Amazon CloudWatch RUM ou dans d'autres services peuvent être incluses dans les journaux de diagnostic. 



## CloudWatch Cookies du client Web RUM (ou technologies similaires)
<a name="CloudWatch-RUM-cookies"></a>

Le client Web CloudWatch RUM collecte certaines données sur les sessions utilisateur par défaut. Vous pouvez choisir d’activer les cookies afin que le client web collecte un ID d’utilisateur et un ID de session persistants d’une page à l’autre. L'ID utilisateur est généré aléatoirement par RUM.

Si ces cookies sont activés, RUM est en mesure d'afficher les types de données suivants lorsque vous consultez le tableau de bord RUM de ce moniteur d'application.
+ Données agrégées basées sur l'utilisateur IDs, telles que le nombre d'utilisateurs uniques et le nombre d'utilisateurs différents ayant rencontré une erreur. 
+ Données agrégées basées sur les sessions IDs, telles que le nombre de sessions et le nombre de sessions ayant rencontré une erreur. 
+ Le *parcours utilisateur*, qui est la séquence de pages incluse dans chaque session utilisateur échantillonnée. 

**Important**  
Si vous n'activez pas ces cookies (ou technologies similaires), le client Web enregistre toujours certaines informations sur les sessions de l'utilisateur final, telles que le navigateurtype/version, operating system type/version, le type d'appareil, etc. Ces informations sont collectées pour fournir des informations agrégées spécifiques aux pages, telles que les signaux web, les consultations de page et les pages présentant des erreurs. Pour de plus amples informations sur les données enregistrées, veuillez consulter [Informations collectées par le client Web CloudWatch RUM](CloudWatch-RUM-datacollected.md).

# Informations collectées par le client Web CloudWatch RUM
<a name="CloudWatch-RUM-datacollected"></a>

Cette section décrit le **PutRumEvents**schéma qui définit la structure des données que vous pouvez collecter à partir de sessions utilisateur à l'aide de CloudWatch RUM.

Une **PutRumEvents**demande envoie une structure de données avec les champs suivants à CloudWatch RUM.
+ ID de ce lot d'événements RUM
+ Détails du moniteur d'application, qui comprennent les éléments suivants :
  + ID du moniteur d'application
  + Version de l'application contrôlée
+ Détails sur les utilisateurs, qui comprennent les éléments suivants.** Ces informations ne sont collectées que si les cookies sont activés sur le moniteur d'application.**
  + ID utilisateur généré par le client web
  + ID de session
+ Tableau des [événements RUM](#CloudWatch-RUM-datacollected-event) dans ce lot

## Schéma d'événements RUM
<a name="CloudWatch-RUM-datacollected-event"></a>

La structure de chaque événement RUM comprend les champs suivants.
+ ID de l'événement
+ Horodatage
+ Type d'événement
+ Agent utilisateur
+ [Metadonnées](#CloudWatch-RUM-datacollected-metadata)
+ [Détails de l'événement RUM](#CloudWatch-RUM-datacollected-eventDetails)

## Métadonnées des événements RUM
<a name="CloudWatch-RUM-datacollected-metadata"></a>

Les métadonnées incluent les métadonnées de page, les métadonnées de l'agent utilisateur, les métadonnées de géolocalisation et les métadonnées de domaine.

### Métadonnées de page
<a name="CloudWatch-RUM-datacollected-metadata-page"></a>

Les métadonnées de page incluent les éléments suivants :
+ ID de la page
+ Titre de la page
+ ID de la page parent. – **Ces informations ne sont collectées que si les cookies sont activés sur le moniteur d'application**.
+ Profondeur d'interaction – **Ces informations ne sont collectées que si les cookies sont activés sur le moniteur d'application.**
+ Balises de page – Vous pouvez ajouter des balises aux événements de page pour regrouper les pages. Pour de plus amples informations, veuillez consulter [Utiliser des groupes de pages](CloudWatch-RUM-page-groups.md).

### Métadonnées de l'agent utilisateur
<a name="CloudWatch-RUM-datacollected-metadata-useragent"></a>

Les métadonnées de l'agent utilisateur incluent les éléments suivants :
+ Langue du navigateur
+ Nom du navigateur
+ Version du navigateur
+ Nom du système d'exploitation
+ Version du système d'exploitation
+ Type d’appareil
+ Types de plateforme

### Métadonnées de géolocalisation
<a name="CloudWatch-RUM-datacollected-metadata-geolocation"></a>

Les métadonnées de géolocalisation incluent les éléments suivants :
+ Code pays
+ Code de subdivision

### Métadonnées de domaine
<a name="CloudWatch-RUM-datacollected-metadata-domain"></a>

Les métadonnées de domaine incluent le domaine d'URL.

## Détails de l'événement RUM
<a name="CloudWatch-RUM-datacollected-eventDetails"></a>

Les détails d'un événement suivent l'un des types de schémas suivants, en fonction du type d'événement.

### Événement de démarrage de session
<a name="CloudWatch-RUM-datacollected-sessionstart"></a>

Cet événement ne contient aucun champ. **Ces informations ne sont collectées que si les cookies sont activés sur le moniteur d'application.**

### Schéma de consultation de page
<a name="CloudWatch-RUM-datacollected-pageview"></a>

Un événement **Page view** (Consultation de page) contient les propriétés suivantes. Vous pouvez configurer le client web pour désactiver la collecte des consultations de page. Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nom | Type | Description | 
| --- | --- | --- | 
|  **Page ID** (ID de la page) |  Chaîne  |  Un ID qui représente cette page de manière unique au sein de l'application. Par défaut, il s'agit du chemin de l'URL.  | 
|  **Parent page ID** (ID de la page parent) |  String  |  L'ID de la page sur laquelle l'utilisateur se trouvait lorsqu'il a accédé à la page actuelle. **Ces informations ne sont collectées que si les cookies sont activés sur le moniteur d'application.**   | 
|  **Interaction depth** (Profondeur d'interaction) |  String  |  **Ces informations ne sont collectées que si les cookies sont activés sur le moniteur d'application.**   | 

### JavaScript schéma d'erreur
<a name="CloudWatch-RUM-datacollected-JavaScriptError"></a>

JavaScript les événements d'erreur générés par l'agent contiennent les propriétés suivantes. Le client web ne collecte ces événements que si vous avez choisi de collecter la télémétrie des erreurs.


| Nom | Type | Description | 
| --- | --- | --- | 
|  **Error type** (Type d'erreur) |  String  |  Le nom de l'erreur, le cas échéant. Pour de plus amples informations, veuillez consulter [Error.prototype.name](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name). Certains navigateurs peuvent ne pas prendre en charge les types d'erreurs.  | 
|  **Error message** (Message d'erreur) |  String  |  Le message de l'erreur. Pour de plus amples informations, veuillez consulter [Error.prototype.message](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message). Si le champ d'erreur n'existe pas, il s'agit du message de l'événement d'erreur. Pour de plus amples informations, veuillez consulter [ErrorEvent](https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent).  Les messages d'erreur peuvent varier d'un navigateur à l'autre.  | 
|  **Stack trace** (Suivi de pile) |  String  |  Le suivi de pile de l'erreur, le cas échéant, tronqué à 150 caractères. Pour de plus amples informations, veuillez consulter [Error.prototype.stack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack).  Certains navigateurs peuvent ne pas prendre en charge les suivis de pile.  | 

### Schéma d'événements DOM
<a name="CloudWatch-RUM-datacollected-DOMEvent"></a>

Les événements DOM (Document Object Model) générés par l'agent contiennent les propriétés suivantes. Par défaut, ces événements ne sont pas collectés. Ils ne sont collectés que si vous activez la télémétrie des interactions. Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nom | Type | Description | 
| --- | --- | --- | 
|  **Event** |  String  |  Le type d'événement DOM, comme un clic, un défilement ou un survol. Pour plus d'informations, consultez [Référence des événements](https://developer.mozilla.org/en-US/docs/Web/Events).  | 
|  **Element** |  String  |  Type d'élément DOM  | 
|  **Element ID** (ID de l'élément) |  String  |  Si l'élément qui a généré l'événement possède un ID, cette propriété stocke cet ID. Pour de plus amples informations, veuillez consulter [Element.id](https://developer.mozilla.org/en-US/docs/Web/API/Element/id).  | 
|  **CSSLocator** |  String  |  Localisateur CSS utilisé pour identifier l'élément DOM.  | 
|  **InteractionId** |  String  |  Un identifiant unique pour l'interaction entre l'utilisateur et l'interface utilisateur.  | 

### Schéma d'événement de navigation
<a name="CloudWatch-RUM-datacollected-NavigationEvent"></a>

Les événements de navigation ne sont collectés que si la télémétrie de performance est activée sur le moniteur d'application.

Les événements de navigation utilisent [le chronométrage de navigation de niveau 1](https://www.w3.org/TR/navigation-timing/#performancetiming) et [le chronométrage de navigation de niveau 2](https://w3c.github.io/navigation-timing) APIs. Le niveau 2 APIs n'étant pas pris en charge sur tous les navigateurs, ces nouveaux champs sont facultatifs.

**Note**  
Les métriques d'horodatage sont basées sur. [DOMHighResTimestamp](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp) Au niveau 2 APIs, tous les horaires sont par défaut relatifs au`startTime`. Mais pour Level 1, la métrique `navigationStart` est soustraite des métriques d'horodatage pour obtenir des valeurs relatives. Toutes les valeurs d'horodatage sont exprimées en millisecondes.

Les événements de navigation contiennent les propriétés suivantes.


| Nom | Type | Description | Remarques | 
| --- | --- | --- | --- | 
|  **initiatorType** |  String  |  Représente le type de ressource qui a initié l'événement de performance.  |  **Valeur :** "navigation" **Level 1 :** "navigation" **Level 2 :** entryData.initiatorType | 
|  **navigationType** |  String  |  Représente le type de navigation. Cet attribut n'est pas obligatoire. |  **Valeur :** cette valeur doit être l'un des éléments suivants. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html) | 
|  **startTime** |  Number  |  Indique quand l'événement est déclenché.  |  **Valeur :** 0 **Level 1 :** entryData.navigationStart - entryData.navigationStart  **Level 2 :** entryData.startTime | 
|  **unloadEventStart** |  Number  |  Indique l'heure à laquelle le déchargement du document précédent de la fenêtre a commencé après que l'événement `unload` a été levé.  |  **Valeur :** s'il n'y a pas de document précédent ou si le document précédent ou l'une des redirections nécessaires ne sont pas de la même origine, la valeur renvoyée est 0. **Level 1 :** <pre>entryData.unloadEventStart > 0<br />  ? entryData.unloadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Niveau 2 : données** d'entrée. unloadEventStart | 
|  **promptForUnload** |  Number  |  Temps nécessaire au déchargement du document. En d'autres termes, le temps entre `unloadEventStart` et `unloadEventEnd`. `UnloadEventEnd` représente le moment, en millisecondes, où le gestionnaire d'événements de déchargement se termine.  |  **Valeur :** s'il n'y a pas de document précédent ou si le document précédent ou l'une des redirections nécessaires ne sont pas de la même origine, la valeur renvoyée est 0. **Niveau 1 : données** d'entrée. unloadEventEnd - Données d'entrée. unloadEventStart **Niveau 2 : données** d'entrée. unloadEventEnd - Données d'entrée. unloadEventStart | 
|  **redirectCount** |  Number  |  Numéro représentant le nombre de redirections depuis la dernière navigation non redirigée dans le contexte de navigation actuel.  Cet attribut n'est pas obligatoire. |  **Valeur :** s'il n'y a pas de redirection ou s'il y a une redirection qui n'est pas de la même origine que le document de destination, la valeur renvoyée est 0. **Level 1 :** non disponible **Level 2 :** entryData.redirectCount | 
|  **redirectStart** |  Number  |  Heure de démarrage de la première redirection HTTP.   |  **Valeur :** s'il n'y a pas de redirection ou s'il y a une redirection qui n'est pas de la même origine que le document de destination, la valeur renvoyée est 0. **Level 1 :** <pre>entryData.redirectStart > 0<br />  ? entryData.redirectStart - entryData.navigationStart<br />  : 0</pre> **Level 2 :** entryData.redirectStart | 
|  **redirectTime** |  Number  |  Le temps nécessaire à la redirection HTTP. Il s'agit de la différence entre `redirectStart` et `redirectEnd`.   |  **Level 1 :** entryData.redirectEnd - entryData.redirectStart **Level 2 :** entryData.redirectEnd - entryData.redirectStart | 
|  **workerStart** |  Number  |  Propriété de l'interface `PerformanceResourceTiming`. Elle marque le début de l'opération de thread de travail. Cet attribut n'est pas obligatoire. |  **Valeur :** si un thread de service worker est déjà en cours d'exécution, ou immédiatement avant le démarrage du thread de service worker, cette propriété renvoie l'heure précédant immédiatement la distribution de `FetchEvent`. Elle renvoie 0 si la ressource n'est pas interceptée par un service worker. **Level 1 :** non disponible **Level 2 :** entryData.workerStart | 
|  **workerTime** |  Number  |  Si la ressource est interceptée par un service worker, cela renvoie le temps requis pour l'opération du thread de travail. Cet attribut n'est pas obligatoire. |  **Level 1 :** non disponible  **Level 2 :** <pre>entryData.workerStart > 0<br />   ? entryData.fetchStart - entryData.workerStart<br />   : 0</pre>  | 
|  **fetchStart** |  Number  |  Heure à laquelle le navigateur est prêt à récupérer le document à l'aide d'une demande HTTP. Et ce, avant de vérifier n'importe quel cache d'application. |  **Level 1 :**  <pre>: entryData.fetchStart > 0<br />  ? entryData.fetchStart - entryData.navigationStart<br />  : 0</pre> **Level 2 :** entryData.fetchStart | 
|  **domainLookupStart** |  Number  |  Heure de démarrage de la recherche de domaine. |  **Valeur :** si une connexion persistante est utilisée ou si les informations sont stockées dans un cache ou une ressource locale, la valeur sera identique à `fetchStart`. **Level 1 :** <pre>entryData.domainLookupStart > 0<br />  ? entryData.domainLookupStart - entryData.navigationStart<br />  : 0</pre> **Niveau 2 : données** d'entrée. domainLookupStart | 
|  **dns** |  Number  |  Temps nécessaire à la recherche de domaines. |  **Valeur :** si les ressources et les enregistrements DNS sont mis en cache, la valeur attendue est 0. **Niveau 1 : données** d'entrée. domainLookupEnd - Données d'entrée. domainLookupStart **Niveau 2 : données** d'entrée. domainLookupEnd - Données d'entrée. domainLookupStart | 
|  **nextHopProtocol** |  String  |  Chaîne représentant le protocole réseau utilisé pour récupérer la ressource. Cet attribut n'est pas obligatoire. |  **Level 1 :** non disponible **Niveau 2 : données** d'entrée. nextHopProtocol | 
|  **connectStart** |  Number  |  Heure précédant immédiatement le lancement par l'agent utilisateur de l'établissement de la connexion au serveur pour récupérer le document. |  **Valeur :** si une connexion RFC2616 persistante est utilisée, ou si le document actuel est extrait des caches d'applications ou des ressources locales appropriés, cet attribut renvoie la valeur de`domainLookupEnd`. **Level 1 :** <pre>entryData.connectStart > 0<br />  ? entryData.connectStart - entryData.navigationStart<br />  : 0</pre> **Level 2 :** entryData.connectStart  | 
|  **connect** |  Number  |  Mesure le temps nécessaire à l'établissement des connexions de transport ou à l'authentification SSL. Il inclut également le temps bloqué qui est pris lorsqu'il y a trop de demandes simultanées émises par le navigateur.  |  **Level 1 :** entryData.connectEnd - entryData.connectStart **Level 2 :** entryData.connectEnd - entryData.connectStart | 
|  **secureConnectionStart** |  Number  |  Si le modèle d'URL de la page actuelle est « https », cet attribut renvoie l'heure précédant immédiatement le lancement par l'agent utilisateur du processus de négociation pour sécuriser la connexion actuelle. Il renvoie 0 si HTTPS n'est pas utilisé. Pour plus d'informations sur les modèles d'URL, consultez [URL representation](https://url.spec.whatwg.org/#concept-url-scheme).  |  **Formule :** EntryData. secureConnectionStart | 
|  **tlsTime** |  Number  |  Le temps nécessaire pour terminer une négociation SSL.  |  **Level 1 :** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre> **Level 2 :** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre>  | 
|  **requestStart** |  Number  |  Heure précédant immédiatement le début de la demande de ressource par l'agent utilisateur auprès du serveur, des caches d'application pertinents ou des ressources locales.   | **Level 1 :** <pre>: entryData.requestStart > 0<br />  ? entryData.requestStart - entryData.navigationStart<br />  : 0<br /></pre> **Level 2 :** entryData.requestStart | 
|  **timeToFirstoctet** |  Number  |  Temps nécessaire à la réception du premier octet d'informations après l'envoi de la demande. Ce temps est relatif à la valeur `startTime`.   | **Level 1 :** entryData.responseStart - entryData.requestStart **Level 2 :** entryData.responseStart - entryData.requestStart | 
|  **responseStart** |  Number  |  Heure suivant immédiatement la réception par l'analyseur HTTP de l'agent utilisateur du premier octet de la réponse des caches d'application concernés, des ressources locales ou du serveur.   | **Level 1 :** <pre>entryData.responseStart > 0<br />   ? entryData.responseStart - entryData.navigationStart<br />   : 0</pre> **Level 2 :** entryData.responseStart   | 
|  **responseTime** |  String  |  Temps nécessaire à la réception d'une réponse complète sous la forme d'octets provenant des caches d'application concernés, des ressources locales ou du serveur.   | **Level 1 :** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre> **Level 2 :** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre>  | 
|  **domInteractive** |  Number  |  Heure à laquelle l'analyseur a terminé son travail sur le document principal et que le DOM HTML est construit. À ce moment, la valeur `Document.readyState` passe à "interactive" (interactif) et l'événement `readystatechange` correspondant est levé.  | **Level 1 :** <pre>entryData.domInteractive > 0<br />  ? entryData.domInteractive - entryData.navigationStart<br />  : 0</pre> **Level 2 :** entryData.domInteractive  | 
|  **domContentLoadedEventStart** |  Number  |  Représente la valeur temporelle égale à l'heure immédiatement avant que l'agent utilisateur ne déclenche l'événement DOMContent Loaded sur le document actuel. L'événement DOMContent Loaded se déclenche lorsque le document HTML initial a été complètement chargé et analysé. À ce moment, le document HTML principal a terminé l'analyse, le navigateur commence à construire l'arborescence de rendu et les sous-ressources doivent encore être chargées. Cette propriété n'attend pas la fin du chargement des feuilles de style, des images et les sous-cadres.  | **Level 1 :** <pre>entryData.domContentLoadedEventStart > 0<br />  ? entryData.domContentLoadedEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Niveau 2 : données** d'entrée. domContentLoadedEventStart  | 
|  **domContentLoaded** |  Number  |  Cette heure de début et de fin de la construction de l'arborescence de rendu est marquée par `domContentLoadedEventStart` et `domContentLoadedEventEnd`. Il permet à CloudWatch RUM de suivre l'exécution. Cette propriété correspond à la différence entre `domContentLoadedStart` et `domContentLoadedEnd`. Pendant ce temps, DOM et CSSOM sont prêts. Cette propriété attend l'exécution des scripts, à l'exception des scripts asynchrones et de ceux créés dynamiquement. Si les scripts dépendent de feuilles de style, `domContentLoaded` les attend aussi. Cette propriété n'attend pas les images.   Les valeurs réelles de `domContentLoadedStart` et `domContentLoadedEnd` correspondent approximativement à `domContentLoaded` dans le panneau Réseau de Google Chrome. Celui-ci indique le temps de construction de l'arborescence de rendu DOM HTML \$1 CSSOM depuis le début du processus de chargement de la page. Dans le cas des mesures de navigation, la valeur `domContentLoaded` représente la différence entre les valeurs de début et de fin, ce qui correspond au temps nécessaire au téléchargement des sous-ressources et à la construction de l'arborescence de rendu uniquement.    | **Niveau 2 : données** d'entrée. domContentLoadedEventEnd - Données d'entrée. domContentLoadedEventStart  **Niveau 2 : données** d'entrée. domContentLoadedEventEnd - Données d'entrée. domContentLoadedEventStart  | 
|  **domComplete** |  Number  |  Heure précédant immédiatement la définition par le navigateur de la préparation du document actuel sur terminée. À ce stade, le chargement des sous-ressources, telles que des images, est terminé. Cela inclut le temps nécessaire au téléchargement de contenus bloquants tels que le CSS et le contenu synchrone. JavaScript Cette valeur correspond approximativement à `loadTime` dans le panneau Réseau de Google Chrome.   | **Level 1 :** <pre>entryData.domComplete > 0<br />  ? entryData.domComplete - entryData.navigationStart<br />  : 0<br /></pre> **Level 2 :** entryData.domComplete  | 
|  **domProcessingTime** |  Number  |  Durée totale entre la réponse et le début de l'événement de chargement.  | **Niveau 1 : données** d'entrée. loadEventStart - EntryData.ResponseEnd **Niveau 2 : données** d'entrée. loadEventStart - EntryData.ResponseEnd  | 
|  **loadEventStart** |  Number  |  Heure précédant immédiatement le lancement de l'événement `load` du document actif.  |  **Level 1 :** <pre>entryData.loadEventStart > 0<br />  ? entryData.loadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Niveau 2 : données** d'entrée. loadEventStart | 
|  **loadEventTime** |  Number  |  Différence entre `loadEventStart` et `loadEventEnd`. La logique ou les fonctions supplémentaires en attente de cet événement de chargement seront déclenchées pendant cette période. |  **Niveau 1 : données** d'entrée. loadEventEnd - Données d'entrée. loadEventStart **Niveau 2 : données** d'entrée. loadEventEnd - Données d'entrée. loadEventStart | 
|  **duration** |  String  |  Durée correspond au temps de chargement total de la page. Cette propriété enregistre la durée nécessaire au téléchargement de la page principale et de toutes ses sous-ressources synchrones, ainsi qu'au rendu de la page. Le téléchargement des ressources asynchrones telles que les scripts se poursuit ultérieurement. Cette propriété correspond à la différence entre les propriétés `loadEventEnd` et `startTime`.  | **Niveau 1 : données** d'entrée. loadEventEnd - Données d'entrée. NavigationStart **Level 2 :** entryData.duration | 
|  **headerSize** |  Number  |  Renvoie la différence entre `transferSize` et `encodedBodySize`. Cet attribut n'est pas obligatoire.  | **Level 1 :** non disponible **Niveau 2 :** EntryData.TransferSize - EntryData. encodedBodySize **Niveau 2 :** EntryData.TransferSize - EntryData. encodedBodySize | 
|  **compressionRatio** |  Number  |  Rapport entre `encodedBodySize` et `decodedBodySize`. La valeur de `encodedBodySize` correspond à la taille compressée de la ressource, à l'exclusion des en-têtes HTTP. La valeur de `decodedBodySize` correspond à la taille décompressée de la ressource, à l'exclusion des en-têtes HTTP. Cet attribut n'est pas obligatoire.  | **Level 1 :** non disponible. **Level 2 :**<pre>entryData.encodedBodySize > 0<br />  ? entryData.decodedBodySize / entryData.encodedBodySize<br />  : 0</pre>  | 
|  **navigationTimingLevel** |  Number  |  Version de l'API Navigation Timing.  | **Valeur :** 1 ou 2  | 

### Schéma d'événement de ressource
<a name="CloudWatch-RUM-datacollected-ResourceEvent"></a>

Les événements de ressource ne sont collectés que si la télémétrie de performance est activée sur le moniteur d'application.

Les métriques d'horodatage sont basées sur [le DOMHigh ResTimeStamp ](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp) typedef. Au niveau 2 APIs, par défaut, tous les horaires sont relatifs au`startTime`. Mais pour le niveau 1 APIs, la `navigationStart` métrique est soustraite des métriques d'horodatage pour obtenir des valeurs relatives. Toutes les valeurs d'horodatage sont exprimées en millisecondes.

Les événements de ressource générés par l'agent contiennent les propriétés suivantes.


| Nom | Type | Description | Remarques | 
| --- | --- | --- | --- | 
|  **targetUrl** |  String  |  Renvoie l'URL de la ressource.  |  **Formule :** [entryData.name](http://entrydata.name/) | 
|  **initiatorType** |  String  |  Représente le type de ressource qui a initié l'événement de ressource de performance.  |  **Valeur :** "ressource" **Formule :** entryData.initiatorType | 
|  **duration** |  String  |  Renvoie la différence entre les propriétés `responseEnd` et `startTime`.Cet attribut n'est pas obligatoire.  | **Formule :** entryData.duration | 
|  **transferSize** |  Number  |  Renvoie la taille (en octets) de la ressource récupérée, y compris les champs d'en-tête de réponse et le corps de la charge utile de réponse.Cet attribut n'est pas obligatoire.  | **Formule :** entryData.transferSize | 
|  **fileType** |  String  |  Extensions dérivées du modèle d'URL cible.  |   | 

### Schéma d'événement Largest Contentful Paint
<a name="CloudWatch-RUM-datacollected-LargestPaintEvent"></a>

Les événements Largest Contentful Paint contiennent les propriétés suivantes.

Ces événements ne sont collectés que si la télémétrie de performance est activée sur le moniteur d'application.


| Nom | Description | 
| --- | --- | 
|  **Valeur** |  Pour de plus amples informations, veuillez consulter [Web Vitals](https://web.dev/vitals/).  | 

### Événement First Input Delay
<a name="CloudWatch-RUM-datacollected-FirstInputDelayEvent"></a>

Les événements First Input Delay contiennent les propriétés suivantes.

Ces événements ne sont collectés que si la télémétrie de performance est activée sur le moniteur d'application.


| Nom | Description | 
| --- | --- | 
|  **Valeur** |  Pour de plus amples informations, veuillez consulter [Web Vitals](https://web.dev/vitals/).  | 

### Événement Cumulative Layout Shift
<a name="CloudWatch-RUM-datacollected-CumulativeShift"></a>

Les événements Cumulative Layout Shift contiennent les propriétés suivantes.

Ces événements ne sont collectés que si la télémétrie de performance est activée sur le moniteur d'application.


| Nom | Description | 
| --- | --- | 
|  **Valeur** |  Pour de plus amples informations, veuillez consulter [Web Vitals](https://web.dev/vitals/).  | 

### Événement HTTP
<a name="CloudWatch-RUM-datacollected-HTTP"></a>

Les événements HTTP peuvent contenir les propriétés suivantes. Ils contiendront un champ `Response` ou `Error`, mais pas les deux.

Ces événements ne sont collectés que si la télémétrie HTTP est activée sur le moniteur d'application.


| Nom | Description | 
| --- | --- | 
|  **Demande** |  Le champ de requête inclut les éléments suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Réponse** |  Le champ de réponse inclut les éléments suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Error (Erreur)** |  Le champ d'erreur peut inclure les éléments suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 

### Schéma d'événement de suivi X-Ray
<a name="CloudWatch-RUM-datacollected-xraytraceEvent"></a>

Ces événements ne sont collectés que si le suivi X-Ray est activé sur le moniteur d'application.

Pour plus d'informations sur les schémas d'événements de suivi X-Ray, consultez [Documents de segment AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-api-segmentdocuments.html).

# Calendrier de changement de route pour les applications monopages
<a name="CloudWatch-RUM-route-change-timing"></a>

Dans une application multipage traditionnelle, lorsqu'un utilisateur demande le chargement d'un nouveau contenu, il demande en fait une nouvelle page HTML au serveur. Par conséquent, le client Web CloudWatch RUM capture les temps de chargement à l'aide des indicateurs de performance habituels de l'API.

Cependant, les applications Web à page unique utilisent JavaScript Ajax pour mettre à jour l'interface sans charger une nouvelle page depuis le serveur. Les mises à jour d'une seule page ne sont pas enregistrées par l'API de synchronisation du navigateur, mais utilisent la synchronisation des changements de route.

CloudWatch RUM prend en charge la surveillance des chargements de pages complètes depuis le serveur et des mises à jour d'une seule page, avec les différences suivantes :
+ Pour la synchronisation des changements de route, il n'existe pas de mesures fournies par le navigateur, telles que `tlsTime`, `timeToFirstByte`, etc.
+ Pour la synchronisation des changements de route, le champ `initiatorType` sera `route_change`. 

Le client Web CloudWatch RUM écoute les interactions des utilisateurs susceptibles d'entraîner un changement d'itinéraire, et lorsqu'une telle interaction est enregistrée, le client Web enregistre un horodatage. Le minutage du changement de route commence alors si les deux conditions suivantes sont vraies :
+ Une API d'historique du navigateur (à l'exception des boutons avant et arrière du navigateur) a été utilisée pour effectuer le changement de route.
+ La différence entre l'heure de détection du changement de route et l'horodatage de la dernière interaction utilisateur est inférieure à 1 000 ms. Cela permet d'éviter une distorsion des données.

Ensuite, une fois que la synchronisation du changement de route commence, celle-ci se termine s'il n'y a pas de requêtes AJAX et de mutations DOM en cours. Ensuite, l'horodatage de la dernière activité terminée sera utilisé comme horodatage de fin.

Le délai de changement de route expire s'il y a des requêtes AJAX ou des mutations DOM en cours pendant plus de 10 secondes (par défaut). Dans ce cas, le client Web CloudWatch RUM n'enregistrera plus l'heure de ce changement d'itinéraire.

Par conséquent, la durée d'un événement de changement de route est calculée comme suit :

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

# Gérez vos applications qui utilisent CloudWatch RUM
<a name="CloudWatch-RUM-manage"></a>

Suivez les étapes décrites dans ces sections pour gérer l'utilisation du CloudWatch RUM par vos applications.

**Topics**
+ [Comment puis-je trouver un extrait de code que j'ai déjà généré ?](CloudWatch-RUM-find-code-snippet.md)
+ [Modification des paramètres du moniteur de votre application CloudWatch RUM](CloudWatch-RUM-edit-application.md)
+ [Arrêter d'utiliser CloudWatch RUM ou supprimer un moniteur d'application](CloudWatch-RUM-delete-appmonitor.md)

# Comment puis-je trouver un extrait de code que j'ai déjà généré ?
<a name="CloudWatch-RUM-find-code-snippet"></a>

Pour trouver un extrait de code CloudWatch RUM que vous avez déjà généré pour une application, procédez comme suit.

**Pour trouver un extrait de code que vous avez déjà généré**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Accédez à l'onglet **Configuration**, section **Extraits de code.**

1. Choisissez **Copier/Télécharger** pour votre instrumentation respective.

# Modification des paramètres du moniteur de votre application CloudWatch RUM
<a name="CloudWatch-RUM-edit-application"></a>

Pour modifier les paramètres d'un moniteur d'application, suivez ces étapes. Vous pouvez modifier tous les paramètres, à l'exception du nom du moniteur d'application.

**Pour modifier la façon dont votre application utilise CloudWatch RUM**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez le bouton en regard du nom de l'application, puis choisissez **Actions**, **Edit** (Modifier).

1. Modifiez les paramètres, à l'exception du nom de l'application. Pour plus d'informations sur les paramètres, consultez [Création d'un moniteur d'application CloudWatch RUM pour une application Web](CloudWatch-RUM-get-started-create-app-monitor.md).

1. Lorsque vous avez terminé, choisissez **Save (Sauvegarder)**.

   La modification des paramètres modifie l'extrait de code. Vous devez maintenant coller l'extrait de code mis à jour dans votre application.

1. **Une fois l'extrait de code créé, choisissez **Copier dans le presse-papiers** ou **Télécharger**, puis cliquez sur Terminé.**

   Pour démarrer la surveillance avec les nouveaux paramètres, vous devez insérer l'extrait de code dans votre application.

# Arrêter d'utiliser CloudWatch RUM ou supprimer un moniteur d'application
<a name="CloudWatch-RUM-delete-appmonitor"></a>

Pour arrêter d'utiliser CloudWatch RUM avec une application, supprimez l'extrait de code généré par RUM du code de votre application.

Pour supprimer un moniteur d'application RUM, suivez ces étapes.

**Pour supprimer un moniteur d'application**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez le bouton en regard du nom de l'application, puis choisissez **Actions**, **Delete** (Supprimer).

1. Dans la zone de confirmation, saisissez **Delete**, puis choisissez **Delete** (Supprimer).

1. Si ce n'est pas déjà fait, supprimez l'extrait de code CloudWatch RUM du code de votre application.

# Résolution des problèmes liés CloudWatch à
<a name="CloudWatch-RUM-troubleshooting"></a>

Cette section contient des conseils pour vous aider à résoudre les problèmes liés à CloudWatch RUM.

## Aucune donnée n'est disponible pour mon application
<a name="CloudWatch-RUM-troubleshooting-nodata"></a>

Tout d'abord, assurez-vous que l'extrait de code a été correctement inséré dans votre application. Pour de plus amples informations, veuillez consulter [Insertion de l'extrait de code du moniteur d' CloudWatch applications dans votre application](CloudWatch-RUM-get-started-insert-code-snippet.md).

Si le problème ne vient pas de là, il est possible que votre application n'ait pas encore reçu de trafic. Générez du trafic en accédant à votre application de la même manière qu'un utilisateur le ferait.

## Les données ont cessé d'être enregistrées pour mon application
<a name="CloudWatch-RUM-troubleshooting-nonewdata"></a>

Votre application a peut-être été mise à jour et ne contient plus d'extrait de code CloudWatch RUM. Vérifiez le code de l'application.

Il est également possible que quelqu'un ait mis à jour l'extrait de code sans insérer ensuite l'extrait de code mis à jour dans l'application. Recherchez l'extrait de code correct actuel en suivant les instructions de la section [Comment puis-je trouver un extrait de code que j'ai déjà généré ?](CloudWatch-RUM-find-code-snippet.md) et comparez-le à l'extrait de code collé dans votre application.