Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

Con CloudWatch RUM, puoi eseguire il monitoraggio reale degli utenti per raccogliere e visualizzare i dati lato client sulle prestazioni delle tue applicazioni web e mobili dalle sessioni utente effettive quasi in tempo reale. Per le applicazioni Web, è possibile analizzare i tempi di caricamento delle pagine, gli errori lato client e il comportamento degli utenti. Per le applicazioni mobili, puoi monitorare i tempi di caricamento dello schermo, i tempi di avvio delle app, gli errori di rete, i crash e i problemi specifici della piattaforma come Android Application Not Responding (ANR) e iOS App Hangs. Quando visualizzi questi dati, puoi vederli tutti aggregati insieme e visualizzare anche le suddivisioni per tipo di dispositivo, sistema operativo e altre caratteristiche dell'utilizzo dell'applicazione.

È possibile utilizzare i dati raccolti per identificare ed eseguire rapidamente il debug dei problemi di prestazioni sul lato client. CloudWatch RUM consente di visualizzare le anomalie nelle prestazioni delle applicazioni e di trovare dati di debug pertinenti come messaggi di errore, tracce dello stack e sessioni utente. È inoltre possibile utilizzare RUM per comprendere la gamma di impatti sugli utenti finali, tra cui il numero di utenti, le geolocalizzazioni e gli utenti utilizzati. browsers/devices 

I dati degli utenti finali raccolti per CloudWatch RUM vengono conservati per 30 giorni e quindi eliminati automaticamente. Se desideri conservare i dati di telemetria RUM per un periodo più lungo, puoi scegliere di far sì che l'app Monitor invii copie della telemetria ai registri del tuo account. CloudWatch Quindi, è possibile modificare il periodo di conservazione per quel gruppo di log.

Per usare RUM, si crea un *app monitor* e si forniscono alcune informazioni. RUM genera un frammento di codice che puoi usare per aggiungere un'iniezione di dipendenza all'applicazione. Lo snippet inserisce il codice client RUM secondo necessità. Il client RUM acquisisce i dati da una percentuale delle sessioni utente dell'applicazione, che vengono visualizzati in una dashboard predefinita. È possibile specificare la percentuale di sessioni utente da cui raccogliere i dati.

 CloudWatch RUM è integrato con [Application Signals](CloudWatch-Application-Monitoring-Sections.md), che può scoprire e monitorare i servizi applicativi, i client, i canali Synthetics e le dipendenze dei servizi. Utilizza Application Signals per visualizzare un elenco o una mappa visiva dei tuoi servizi, visualizzare le metriche sanitarie in base agli obiettivi del livello di servizio (SLOs) e approfondire le tracce a raggi X correlate per una risoluzione dei problemi più dettagliata. Per visualizzare le richieste delle pagine client RUM in Application Signals, attiva il tracciamento attivo a raggi X durante la [creazione di un](CloudWatch-RUM-get-started-create-app-monitor.md) app monitor. Per le applicazioni web, puoi anche abilitarlo [configurando manualmente il client web RUM](CloudWatch-RUM-configure-client.md). I tuoi client RUM vengono visualizzati nella [mappa dell'applicazione](ServiceMap.md) connessa ai tuoi servizi e nella pagina dei [dettagli del servizio](ServiceDetail.md) dei servizi che richiamano. 

I client RUM sono open source. Per ulteriori informazioni, consulta il [client web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web), l'SDK [Android AWS Distro per OpenTelemetry (ADOT) e l'SDK AWS](https://github.com/aws-observability/aws-otel-android) [Distro per ( OpenTelemetry ADOT](https://github.com/aws-observability/aws-otel-swift)) iOS.

**Prezzi di RUM**

Per informazioni sui prezzi, consulta la pagina [ CloudWatch dei prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/). 

**Disponibilità nelle Regioni**

CloudWatch RUM è attualmente disponibile nelle seguenti regioni:
+ Stati Uniti orientali (Virginia settentrionale)
+ Stati Uniti orientali (Ohio)
+ Stati Uniti occidentali (California settentrionale)
+ Stati Uniti occidentali (Oregon)
+ Africa (Città del Capo)
+ AWS GovCloud (Stati Uniti orientali)
+ AWS GovCloud (Stati Uniti occidentali)
+ Asia Pacifico (Mumbai)
+ Asia Pacifico (Hyderabad)
+ Asia Pacifico (Melbourne)
+ Asia Pacifico (Osaka)
+ Asia Pacifico (Seoul)
+ Asia Pacifico (Singapore)
+ Asia Pacifico (Sydney)
+ Asia Pacifico (Giacarta)
+ Asia Pacifico (Malesia)
+ Asia Pacifico (Thailandia)
+ Asia Pacifico (Tokyo)
+ Asia Pacifico (Hong Kong)
+ Canada (Centrale)
+ Europa (Francoforte)
+ Europa (Irlanda)
+ Europa (Londra)
+ Europa (Milano)
+ Europa (Parigi)
+ Europa (Spagna)
+ Europa (Stoccolma)
+ Europa (Zurigo)
+ AWS European Sovereign Cloud (Germania)
+ Medio Oriente (Bahrein)
+ Medio Oriente (Emirati Arabi Uniti)
+ Messico (centrale)
+ Sud America (San Paolo)
+ Israele (Tel Aviv)
+ Canada occidentale (Calgary)

# Configura un'applicazione mobile per utilizzare RUM CloudWatch
<a name="CloudWatch-RUM-web-mobile"></a>

Per monitorare le applicazioni mobili, devi creare un app monitor, configurarlo per piattaforme mobili e integrare l'SDK AWS Distro for OpenTelemetry (ADOT) nella tua applicazione. Mobile RUM utilizza il OpenTelemetry protocollo (OTLP) per inviare dati di telemetria a un endpoint OTLP dedicato. 

## Per creare un monitor di app per una piattaforma mobile
<a name="mobile-platform-app-monitor"></a>

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli **Aggiungere un monitor app**.

1. Per **il nome del monitor dell'app**, inserisci un nome da utilizzare per identificare questo app monitor all'interno della console CloudWatch RUM.

1. Seleziona **Android** o **iOS** come piattaforma.

1. In **Archiviazione dati**, puoi scegliere di archiviare copie degli eventi e degli intervalli di registro di RUM OTEL nei CloudWatch registri e configurare la conservazione. Per impostazione predefinita, il gruppo CloudWatch Logs log conserva i dati per 30 giorni. È possibile modificare il periodo di conservazione nella console CloudWatch Logs.

1. (Facoltativo) In **Politica basata sulle risorse**, scegli di aggiungere una politica basata sulle risorse per controllare chi può inviare richieste al monitor dell'app. Se scegli **Crea policy pubblica**, verrà allegata una policy sulle risorse che consente a chiunque di inviare richieste al monitor dell'app. Per ulteriori informazioni, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Per abilitare il tracciamento a AWS raggi X delle sessioni utente campionate, scegli Tracciamento **attivo e seleziona Traccia il **mio** servizio** con X-Ray. AWS 

   Se selezionato, vengono tracciati gli intervalli OTEL generati durante le sessioni utente campionate. È quindi possibile visualizzare le tracce e gli intervalli di queste sessioni nella dashboard RUM e nella mappa di traccia a raggi X e nelle pagine dei dettagli della traccia. Queste sessioni utente verranno visualizzate anche come pagine client in Application Signals dopo che l'avrai abilitata per la tua applicazione.

1. (Facoltativo) Per aggiungere tag al monitor dell'app:

   1. Scegli **Tag**, **Aggiungi nuovo tag**.

   1. Per **Chiave**, inserisci un nome per il tag. È possibile aggiungere un valore opzionale in **Valore**.

   1. Per aggiungere un altro tag, scegli nuovamente **Add tag** (Aggiungi tag).

   Per ulteriori informazioni, consulta [Tagging AWS Resources](https://docs.aws.amazon.com/tagging/latest/userguide/tagging-resources.html) nella *AWS Tagging and Tag Editor User Guide*.

1. Scegli **Aggiungere un monitor app**.

1. Nella sezione **Codice di esempio**, puoi copiare lo snippet di codice da aggiungere all'applicazione. Utilizzando l'SDK AWS Distro for OpenTelemetry (ADOT), puoi scegliere tra **Manual Instrumentation** per configurare il monitoraggio nel codice dell'applicazione o **Zero-Code** Instrumentation che richiede modifiche minime alla configurazione.

   Per entrambe le applicazioni Android e iOS, Zero-Code Instrumentation è l'opzione più semplice in quanto inizializza automaticamente la raccolta di telemetria utilizzando un file di configurazione. Manual Instrumentation offre un maggiore controllo sul processo di inizializzazione e configurazione.

1. Scegli **Copy** (Copia) o **Download** (Scarica), quindi scegli **Done** (Fatto).

### Configurazione dell'applicazione iOS
<a name="CloudWatch-RUM-ios-setup"></a>

Per le applicazioni iOS, integra l'[SDK iOS AWS Distro for OpenTelemetry (ADOT](https://github.com/aws-observability/aws-otel-swift)) per abilitare il monitoraggio RUM. L'SDK supporta iOS 16 e versioni successive e fornisce strumentazione automatica per scenari prestazionali comuni.

### Configurazione dell'applicazione Android
<a name="CloudWatch-RUM-android-setup"></a>

Per le applicazioni Android, integra l'[SDK Android AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android) per abilitare il monitoraggio RUM. L'SDK fornisce strumentazione automatica e supporta modelli di autenticazione firmati e non firmati.

## Autenticazione e sicurezza
<a name="CloudWatch-RUM-authentication"></a>

Mobile RUM supporta modelli di autenticazione flessibili come definiti nella loro SDKs.
+ Le applicazioni iOS utilizzano l'[AWS SDK iOS Distro for OpenTelemetry (ADOT](https://github.com/aws-observability/aws-otel-swift)). 
+ Le applicazioni Android utilizzano l'SDK Android [AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android).

# Politiche IAM per l'utilizzo di RUM CloudWatch
<a name="CloudWatch-RUM-permissions"></a>

Per poter gestire completamente CloudWatch RUM, devi accedere come utente o ruolo IAM con la policy di **AmazonCloudWatchRUMFullAccess** IAM. Inoltre, potrebbero essere necessari altri criteri o autorizzazioni:
+ Per creare un app monitor che crei un nuovo pool di identità Amazon Cognito per l'autorizzazione, devi disporre del ruolo **Admin** IAM o della policy **AdministratorAccess**IAM.
+ Per creare un app monitor che invii dati a CloudWatch Logs, devi accedere a un ruolo o a una policy IAM con le seguenti autorizzazioni:

  ```
  {
      "Effect": "Allow",
      "Action": [
          "logs:PutResourcePolicy"
      ],
      "Resource": [
          "*"
      ]
  }
  ```
+ Per abilitare le mappe di JavaScript origine nel monitor di un'app, dovrai caricare i file delle mappe di origine in un bucket Amazon S3. La tua policy o il tuo ruolo IAM richiedono autorizzazioni Amazon S3 specifiche che consentano di creare bucket Amazon S3, impostare policy di bucket e gestire i file nel bucket. Per motivi di sicurezza, assegna queste autorizzazioni a risorse specifiche. La policy di esempio riportata di seguito limita l'accesso ai bucket che contengono `rum` nei relativi nomi e utilizza la chiave di condizione `aws:ResourceAccount` per limitare le autorizzazioni solo all'account principale.

  ```
  {
      "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}"
          }
      }
  }
  ```
+ Per utilizzare AWS KMS le tue chiavi per la crittografia lato server sul tuo bucket di mappe di origine, il tuo ruolo o policy IAM avrà bisogno di AWS KMS autorizzazioni specifiche che consentano di creare una chiave, aggiornare la policy delle chiavi, utilizzare la chiave con AWS KMS Amazon S3 e impostare la configurazione di crittografia del tuo bucket Amazon S3. Per motivi di sicurezza, assegna queste autorizzazioni a scopi specifici. L'esempio seguente limita l'accesso alle chiavi per una regione e AccountID specifici e presenta restrizioni S3 simili a quelle dell'esempio precedente. 

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

La policy può essere concessa ad altri utenti che devono visualizzare i dati CloudWatch RUM ma non devono creare risorse CloudWatch RUM. **AmazonCloudWatchRUMReadOnlyAccess**

# Configura un'applicazione web per usare CloudWatch RUM
<a name="CloudWatch-RUM-get-started"></a>

Utilizzate i passaggi riportati in queste sezioni per configurare l'applicazione Web e iniziare a utilizzare CloudWatch RUM per raccogliere dati sulle prestazioni da sessioni utente reali.

**Topics**
+ [Autorizza la tua applicazione web a inviare dati a AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Creazione di un monitor di app CloudWatch RUM per un'applicazione web](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Modifica dello snippet di codice per configurare il client web CloudWatch RUM (opzionale)](CloudWatch-RUM-modify-snippet.md)
+ [Inserimento dello snippet di codice del monitor CloudWatch dell'app nell'applicazione](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Verifica della configurazione del monitor CloudWatch dell'app generando eventi utente](CloudWatch-RUM-get-started-generate-data.md)

# Autorizza la tua applicazione web a inviare dati a AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Sono disponibili quattro opzioni per impostare l'autenticazione dei dati:
+ Usa Amazon Cognito e consenti a CloudWatch RUM di creare un nuovo pool di identità Amazon Cognito per l'applicazione. Questo metodo richiede il minimo sforzo per la configurazione.

  Il pool di identità conterrà un'identità non autenticata. Ciò consente al client web CloudWatch RUM di inviare dati a CloudWatch RUM senza autenticare l'utente dell'applicazione.

  Il pool di identità di Amazon Cognito ha un ruolo IAM associato. L'identità non autenticata di Amazon Cognito consente al client Web di assumere il ruolo IAM autorizzato a inviare dati a RUM. CloudWatch 
+ Utilizzare Amazon Cognito per l'autenticazione. In questo modo, puoi impiegare un pool di identità di Amazon Cognito esistente o crearne uno nuovo da utilizzare con questo monitor dell'app. Se utilizzi un pool di identità esistente, è anche necessario modificare il ruolo IAM associato al pool di identità. Utilizza questa opzione per i pool di identità che supportano utenti non autenticati. Puoi utilizzare i pool di identità solo dalla stessa Regione.
+ Utilizzare l'autenticazione da un provider di identità esistente già configurato. In questo caso, è necessario ottenere le credenziali dal provider di identità e l'applicazione deve inoltrare queste credenziali al client Web RUM.

  Utilizza questa opzione per i pool di identità che supportano solo utenti autenticati.
+ Utilizzare le policy basate su risorse per gestire l'accesso al monitor dell'app. Ciò include la possibilità di inviare richieste non autenticate a RUM senza credenziali. CloudWatch AWS Per ulteriori informazioni sulle policy basate su risorse e RUM, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

Le seguenti sezioni includono maggiori dettagli su queste opzioni.

## Utilizzare un pool di identità Amazon Cognito esistente
<a name="CloudWatch-RUM-get-started-authorization-existingcognito"></a>

Se scegli di utilizzare un pool di identità Amazon Cognito, specifichi il pool di identità quando aggiungi l'applicazione a CloudWatch RUM. Il pool deve supportare l'abilitazione dell'accesso a identità non autenticate. Puoi utilizzare i pool di identità solo dalla stessa Regione.

È inoltre necessario aggiungere le seguenti autorizzazioni alla policy IAM associata al ruolo IAM associato a questo pool di identità.

------
#### [ 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 invierà quindi il token di sicurezza necessario per consentire all'applicazione di accedere CloudWatch a RUM.

## Fornitore di terza parte
<a name="CloudWatch-RUM-get-started-authorization-thirdparty"></a>

Se si sceglie l'autenticazione privata da un provider di terze parti, è necessario ottenere le credenziali dal provider di identità e inoltrarle a AWS. Il modo migliore per eseguire questa operazione è possibile utilizzare un *fornitore di token di sicurezza*. Puoi utilizzare qualsiasi fornitore di token di sicurezza, incluso Amazon Cognito AWS Security Token Service con. Per ulteriori informazioni su AWS STS, consulta [Welcome to the AWS Security Token Service API](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) Reference. 

Se si desidera utilizzare Amazon Cognito come fornitore di token in questo scenario, è possibile configurare Amazon Cognito in modo che funzioni con un provider di autenticazione. Per maggiori informazioni, consulta [Nozioni di base sui pool di identità di Amazon Cognito (identità federate)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html)

Dopo aver configurato Amazon Cognito per lavorare con il proprio provider di identità, è necessario anche fare quanto segue:
+ Creare un ruolo IAM con le seguenti autorizzazioni. L'applicazione utilizzerà questo ruolo per accedere a AWS.

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

****  

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

------
+ Aggiungi quanto segue alla tua applicazione per farla passare le credenziali dal tuo provider a CloudWatch RUM. Inserire la riga in modo che venga eseguita dopo che un utente ha effettuato l'accesso all'applicazione e l'applicazione ha ricevuto le credenziali da utilizzare per accedere a AWS.

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

[Per ulteriori informazioni sui provider di credenziali nell' AWS JavaScript SDK, consulta [Impostazione delle credenziali in un browser Web nella](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) guida per sviluppatori v3 per SDK per JavaScript, [Impostazione delle credenziali in un browser Web nella](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) guida per sviluppatori v2 per SDK per e @aws -sdk/credential-providers. JavaScript](https://www.npmjs.com/package/@aws-sdk/credential-providers) 

Puoi anche utilizzare l'SDK per il client Web RUM per configurare i metodi di autenticazione del client Web. CloudWatch Per ulteriori informazioni sul web client SDK, consulta [CloudWatch RUM web client](https://github.com/aws-observability/aws-rum-web) SDK. 

# Creazione di un monitor di app CloudWatch RUM per un'applicazione web
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Per iniziare a utilizzare CloudWatch RUM con la tua applicazione, devi creare un *app monitor*. Quando viene creato l'app monitor, RUM genera un frammento di codice da incollare nell'applicazione. Lo snippet inserisce il codice client RUM. Il client RUM acquisisce i dati dalle sessioni utente dell'applicazione e li invia a RUM.

## Per creare un app monitor per una piattaforma web
<a name="web-platform-app-monitor"></a>

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli **Aggiungere un monitor app**.

1. Per **il nome del monitor dell'app**, inserisci un nome da utilizzare per identificare questo app monitor all'interno della console CloudWatch RUM.

1. Seleziona **Web** come piattaforma.

1. Per **Elenco dominio applicazione**, inserire i nomi di dominio registrati in cui l'applicazione dispone dell'autorità amministrativa. Puoi anche utilizzare un carattere jolly `*` per consentire qualsiasi sottodominio o dominio di primo livello (ad esempio, \$1.amazon.com, amazon.\$1 o \$1.amazon.\$1).

1. Per **Configurazione della raccolta dei dati**, specificare se si desidera che il monitor dell'app raccolga ciascuno dei seguenti elementi:
   + **Telemetria delle prestazioni**— Raccoglie informazioni sul caricamento della pagina e sui tempi di caricamento delle risorse
   + **JavaScript errori**: raccoglie informazioni sugli JavaScript errori non gestiti generati dall'applicazione

     È possibile selezionare **Unminify JavaScript error stack trace per eseguire il debug degli errori** non minimizzati. JavaScript Per utilizzare questa funzionalità, carica i file delle mappe di origine in un bucket o in una cartella Amazon S3 e fornisci l'URI Amazon S3. Una volta abilitata, RUM utilizzerà queste mappe di origine e arricchirà gli eventi di JavaScript errore aggiungendo lo stack trace non minimizzato. Nota che, dopo l'attivazione, questa funzionalità elabora solo nuovi eventi di JavaScript errore e non può essere utilizzata su dati raccolti in precedenza. Per ulteriori informazioni, consulta [Abilitazione della riduzione delle tracce dello stack di JavaScript errori](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **Errori HTTP**— Raccoglie informazioni sugli errori HTTP generati dall'applicazione

   La selezione di queste opzioni fornisce ulteriori informazioni sull'applicazione, ma genera anche più eventi CloudWatch RUM e quindi comporta costi aggiuntivi.

   Se non selezioni nessuna di queste opzioni, l'app monitor raccoglie comunque gli eventi e la pagina di inizio della sessione IDs in modo da poter vedere quanti utenti stanno utilizzando l'applicazione, comprese le suddivisioni per tipo e versione del sistema operativo, tipo e versione del browser, tipo di dispositivo e posizione.

1. Seleziona **Seleziona questa opzione per consentire al CloudWatch RUM Web Client di impostare i cookie** se desideri poter raccogliere utenti IDs e sessioni IDs da sessioni utente campionate. Gli utenti IDs vengono generati casualmente da RUM. Per ulteriori informazioni, consulta [CloudWatch Cookie del client web RUM (o tecnologie simili)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. Per **Esempi di sessione**, inserire la percentuale di sessioni utente che verranno utilizzate per raccogliere i dati RUM. Il valore di default è 100%. La riduzione di questo numero consente di ottenere meno dati, ma riduce i costi. Per ulteriori informazioni sui prezzi di RUM, consulta [Prezzi di RUM](CloudWatch-RUM.md#RUMpricing).

1. I dati degli utenti finali raccolti per CloudWatch RUM vengono conservati per 30 giorni e quindi eliminati. **Se desideri conservare copie degli eventi RUM nei CloudWatch registri e configurare per quanto tempo conservare tali copie, scegli **Seleziona questa opzione per memorizzare i dati di telemetria dell'applicazione nel tuo account CloudWatch Logs in Archiviazione dati**.** Per impostazione predefinita, il gruppo di CloudWatch log Logs conserva i dati per 30 giorni. È possibile modificare il periodo di conservazione nella console CloudWatch Logs.

1. (Facoltativo) Scegli di aggiungere una policy basata sulle risorse al monitor dell'app per controllare chi può inviare richieste `PutRumEvents` al monitor stesso. Se scegli **Crea policy pubblica**, al monitor dell'app verrà allegata una policy relativa alle risorse che consente a chiunque di inviare richieste `PutRumEvents` al monitor stesso. Per ulteriori informazioni su questo metodo, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Se hai allegato una politica basata sulle risorse nel passaggio precedente, non è necessario firmare le richieste a CloudWatch RUM con le AWS credenziali e puoi saltare la configurazione dell'autorizzazione. Altrimenti, per **Autorizzazione**, specifica se utilizzare un pool di identità Amazon Cognito nuovo o esistente o utilizzare un provider di identità diverso. La creazione di un nuovo pool di identità è l'opzione più semplice che non richiede altri passaggi di configurazione. Per ulteriori informazioni, consultare le [Autorizza la tua applicazione web a inviare dati a AWS](CloudWatch-RUM-get-started-authorization.md).

   La creazione di un nuovo pool di identità Amazon Cognito richiede autorizzazioni amministrative. Per ulteriori informazioni, consulta [Politiche IAM per l'utilizzo di RUM CloudWatch](CloudWatch-RUM-permissions.md).

1. (Facoltativo) Per impostazione predefinita, quando aggiungete lo snippet di codice RUM all'applicazione, il client Web inserisce il JavaScript tag per monitorare l'utilizzo nel codice HTML di tutte le pagine dell'applicazione. Per modificarlo, scegli **Configura le pagine** e poi scegli tra **Includi solo queste pagine** o **Escludi queste pagine**. Quindi, specificare le pagine da includere o escludere. Per specificare una pagina da includere o escludere, inserite la pagina completa. URLs Per specificare pagine aggiuntive, scegli **Aggiungi URL**.

1. Per abilitare il AWS X-Ray tracciamento delle sessioni utente campionate dall'app monitor, scegli **Tracciamento attivo** e seleziona **Trace my** service with. AWS X-Ray

   Se si seleziona questo,`XMLHttpRequest` e `fetch` vengono tracciate le richieste effettuate durante le sessioni utente campionate dal monitor dell'app. È quindi possibile visualizzare tracce e segmenti di queste sessioni utente nel pannello di controllo RUM, dalla mappa di tracciamento X-Ray e dalle pagine dei dettagli della traccia. Queste sessioni utente verranno visualizzate anche come pagine client in [Application Signals](CloudWatch-Application-Monitoring-Sections.md) dopo che l'avrai abilitata per la tua applicazione.

   Apportando ulteriori modifiche alla configurazione del client Web CloudWatch RUM, è possibile aggiungere un'intestazione di traccia X-Ray alle richieste HTTP per consentire il end-to-end tracciamento delle sessioni utente fino ai servizi gestiti a valle. AWS Per ulteriori informazioni, consulta [Abilitazione del tracciamento X-Ray end-to-end](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Facoltativo) Per aggiungere tag al monitor dell'app, seleziona **Tag**, **Aggiungi nuovo tag**.

   Poi, per **Chiave**, inserire un nome per il tag. È possibile aggiungere un valore facoltativo al tag in **Value** (Valore). 

   Per aggiungere un altro tag, scegli nuovamente **Add tag** (Aggiungi tag).

   Per ulteriori informazioni, consulta [Assegnazione di tag alle risorse AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).

1. Scegliere **Aggiungere un monitor app**.

1. Nella sezione **Sample code** (Codice di esempio), puoi copiare lo snippet di codice da aggiungere alla tua applicazione. Ti consigliamo di scegliere **JavaScript**o **TypeScript**utilizzare NPM per installare il client web CloudWatch RUM come modulo. JavaScript

   In alternativa, puoi scegliere **HTML** per utilizzare una rete di distribuzione dei contenuti (CDN) per installare il client web CloudWatch RUM. Lo svantaggio dell'utilizzo di una CDN è che il client Web viene spesso bloccato dalle estensioni di blocco degli annunci pubblicitari.

1. Scegli **Copy** (Copia) o **Download** (Scarica), quindi scegli **Done** (Fatto).

# Modifica dello snippet di codice per configurare il client web CloudWatch RUM (opzionale)
<a name="CloudWatch-RUM-modify-snippet"></a>

È possibile modificare lo snippet di codice prima di inserirlo nell'applicazione, per attivare o disattivare diverse opzioni. Per ulteriori informazioni, consulta la documentazione del client [web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).

Ci sono quattro opzioni di configurazione di cui si deve assolutamente essere a conoscenza, come discusso in queste sezioni.

## Impedire la raccolta di risorse URLs che potrebbero contenere informazioni personali
<a name="CloudWatch-RUM-resourceURL"></a>

Per impostazione predefinita, il client web CloudWatch RUM è configurato per registrare le URLs risorse scaricate dall'applicazione. Queste risorse includono file HTML, immagini, file CSS, JavaScript file e così via. Per alcune applicazioni, URLs può contenere informazioni di identificazione personale (PII).

Se questo è il caso della tua applicazione, ti consigliamo vivamente di disabilitare la raccolta di risorse URLs impostando la configurazione dello snippet di codice, prima di inserirla `recordResourceUrl: false` nell'applicazione.

## Registrazione manuale delle visualizzazioni di pagina
<a name="CloudWatch-RUM-pageload"></a>

Per impostazione predefinita, il client Web registra le visualizzazioni di pagina quando la pagina viene caricata per la prima volta e quando viene chiamata l'API della cronologia del browser. L'ID di pagina predefinito è `window.location.pathname`. Tuttavia, in alcuni casi potresti voler ignorare questo comportamento e utilizzare l'applicazione per registrare le visualizzazioni di pagina a livello di codice. In questo modo potrai controllare l'ID della pagina e quando viene registrata. Ad esempio, si consideri un'applicazione Web che dispone di un URI con un identificatore variabile, ad esempio `/entity/123` o`/entity/456`. Per impostazione predefinita, CloudWatch RUM genera un evento di visualizzazione della pagina per ogni URI con un ID di pagina distinto che corrisponde al percorso, ma potresti preferire raggrupparli in base allo stesso ID di pagina. A tale scopo, disabilita l'automazione della visualizzazione delle pagine del client Web utilizzando la configurazione `disableAutoPageView` e utilizza il comando `recordPageView` per impostare l'ID di pagina desiderato. Per ulteriori informazioni, vedere [Configurazioni specifiche dell'applicazione su](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md). GitHub

**Esempio di script incorporato:**

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

**JavaScript esempio di modulo:**

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

## Abilitazione del tracciamento X-Ray end-to-end
<a name="CloudWatch-RUM-xraytraceheader"></a>

Quando si crea il monitor dell'app, selezionando **Traccia il mio servizio con AWS X-Ray** consente il tracciamento di richieste `XMLHttpRequest` e `fetch` effettuate durante le sessioni utente che vengono campionate dal monitor dell'app. È quindi possibile visualizzare le tracce di queste richieste HTTP nella dashboard CloudWatch RUM e nelle pagine X-Ray Trace Map e Trace details.

Per impostazione predefinita, queste tracce lato client non sono collegate a tracce lato server a valle. Per connettere le tracce lato client alle tracce lato server e abilitare la end-to-end traccia, imposta l'`addXRayTraceIdHeader`opzione su Nel client Web. `true` Questo fa sì che il client web CloudWatch RUM aggiunga un'intestazione di traccia X-Ray alle richieste HTTP.

Il seguente blocco di codice mostra un esempio di aggiunta di tracce lato client. Alcune opzioni di configurazione vengono omesse da questo esempio per la leggibilità.

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

**avvertimento**  
La configurazione del client web CloudWatch RUM per aggiungere un'intestazione di traccia X-Ray alle richieste HTTP può causare il fallimento della condivisione delle risorse tra le origini (CORS) o invalidare la firma della richiesta se la richiesta è firmata con SigV4. [Per ulteriori informazioni, consulta la documentazione del client web RUM. CloudWatch ](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md) Si consiglia vivamente di testare l'applicazione prima di aggiungere un'intestazione di traccia X-Ray lato client in un ambiente di produzione.

Per ulteriori informazioni, consulta la [documentazione del client web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http)

## Invio di richieste non firmate a RUM CloudWatch
<a name="CloudWatch-RUM-unsigned"></a>

Per impostazione predefinita, il client web RUM firma tutte le richieste inviate a RUM. Se lo impostate `signing:false` nella configurazione del client, le richieste non saranno firmate quando verranno inviate a CloudWatch RUM. I dati verranno importati in RUM solo se al monitor dell'app è allegata una policy basata su risorse pubbliche. Per ulteriori informazioni, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

# Inserimento dello snippet di codice del monitor CloudWatch dell'app nell'applicazione
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

Successivamente, inserire lo snippet di codice creato nella sezione precedente nell'applicazione.

**avvertimento**  
Il client web, scaricato e configurato dallo snippet di codice, utilizza cookie (o tecnologie simili) per aiutare a raccogliere i dati dell'utente finale. Prima di inserire lo snippet di codice, vedere [Filtraggio in base agli attributi dei metadati nella consoleProtezione e riservatezza dei dati con RUM CloudWatch](CloudWatch-RUM-privacy.md).

Se non si dispone dello snippet di codice generato in precedenza, è possibile trovarlo seguendo le istruzioni in [Come faccio a trovare uno snippet di codice che ho già generato?](CloudWatch-RUM-find-code-snippet.md).

**Per inserire lo snippet di codice CloudWatch RUM nell'applicazione**

1. Inserire lo snippet di codice copiato o scaricato nella sezione precedente all'interno dell'elemento `<head>` della propria applicazione. Inserirlo prima dell'elemento `<body>` o qualsiasi altro tag `<script>`.

   Il seguente è un esempio di uno snippet di codice generato:

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

1. Se l'applicazione è un'applicazione Web multipagina, è necessario ripetere il passaggio 1 per ogni pagina HTML che si desidera includere nella raccolta dati.

# Verifica della configurazione del monitor CloudWatch dell'app generando eventi utente
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Dopo aver inserito lo snippet di codice e quando l'applicazione aggiornata è in esecuzione, è possibile testarlo generando manualmente eventi utente. Per testarlo, consigliamo anche di fare quanto segue. Questo test prevede tariffe RUM standard CloudWatch .
+ Spostarsi tra le pagine dell'applicazione Web.
+ Creare più sessioni utente, utilizzando browser e dispositivi diversi.
+ Eseguire richieste.
+ Causare JavaScript errori.

Dopo aver generato alcuni eventi, visualizzali nella dashboard CloudWatch RUM. Per ulteriori informazioni, consulta [Visualizzazione della dashboard CloudWatch RUM](CloudWatch-RUM-view-data.md).

I dati delle sessioni utente potrebbero richiedere fino a 15 minuti per essere visualizzati nel pannello di controllo.

Se i dati non vengono visualizzati 15 minuti dopo aver generato eventi nell'applicazione, vedere [Risoluzione dei problemi RUM CloudWatch](CloudWatch-RUM-troubleshooting.md).

# Utilizzo di politiche basate sulle risorse con RUM CloudWatch
<a name="CloudWatch-RUM-resource-policies"></a>

È possibile allegare una politica delle risorse a un monitor di app CloudWatch RUM. Per impostazione predefinita, ai monitor delle app non è associata una politica delle risorse. CloudWatch Le politiche basate sulle risorse RUM non supportano l'accesso tra account.

Per ulteriori informazioni sulle politiche relative alle AWS risorse, consulta Politiche basate sull'[identità e politiche basate sulle](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) risorse.

Per ulteriori informazioni su come vengono valutate le policy delle risorse e le policy di identità, consulta [Logica di valutazione delle policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html).

Per ulteriori informazioni sulla grammatica delle policy IAM, consulta la [documentazione di riferimento agli elementi delle policy IAM in formato JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html).

## Azioni supportate
<a name="RUM-resource-policies-actions"></a>

Le policy basate sulle risorse sul monitor dell'app supportano l'azione `rum:PutRumEvents`.

## Esempi di politiche da utilizzare con RUM CloudWatch
<a name="RUM-resource-policies-samples"></a>

L'esempio seguente consente a chiunque di scrivere dati sul monitor dell'app, compresi quelli senza credenziali 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": "*"
        }
    ]
}
```

------

Puoi modificare la policy per bloccare indirizzi IP di origine specificati utilizzando la chiave di condizione `aws:SourceIp`. In questo esempio, utilizzando questa politica, PutRumEvents l'indirizzo IP elencato verrà rifiutato. Al contempo, verranno accettate tutte le altre richieste provenienti da altri indirizzi IP. Per ulteriori informazioni su questa chiave di condizione, consulta [Proprietà della rete](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-network-properties) nella Guida per l'utente di 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"
                }
            }
        }
    ]
}
```

------

Inoltre, è possibile utilizzare la chiave `rum:alias` di contesto del servizio per controllare quali richieste vengono accettate. 

Per i monitor delle app Web, è necessario configurare il client Web per `Alias` l'invio utilizzando la versione 1.20 o successiva del client Web CloudWatch RUM, come descritto in [Configurazioni specifiche dell'applicazione su](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md). GitHub

Per i monitor delle app mobili, è necessario configurare la strumentazione in base all'SDK.
+ Le applicazioni iOS utilizzano l'[AWS SDK iOS Distro for OpenTelemetry (ADOT](https://github.com/aws-observability/aws-otel-swift)). 
+ Le applicazioni Android utilizzano l'SDK Android [AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android).

Nell'esempio seguente, la politica delle risorse richiede che le richieste contengano uno `alias1` o che `alias2` l'evento venga accettato.

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

# Configurazione del client web CloudWatch RUM
<a name="CloudWatch-RUM-configure-client"></a>

Le applicazioni possono utilizzare uno dei frammenti di codice generati da CloudWatch RUM per installare il client web CloudWatch RUM. Gli snippet generati supportano due metodi di installazione: come JavaScript modulo tramite NPM o da una rete di distribuzione dei contenuti (CDN). Per ottenere prestazioni migliori, ti consigliamo di utilizzare il metodo di installazione tramite NPM. Per ulteriori informazioni sull'utilizzo di questo metodo, vedete [Installazione](https://github.com/aws-observability/aws-rum-web/blob/main/docs/npm_installation.md) come modulo. JavaScript 

Se utilizzi l'opzione di installazione CDN, gli ad blocker potrebbero bloccare il CDN predefinito fornito da RUM. CloudWatch Questo disabilita il monitoraggio delle applicazioni per gli utenti che hanno installato estensioni di blocco degli annunci pubblicitari. Per questo motivo, consigliamo di utilizzare il CDN predefinito solo per l'onboarding iniziale con RUM. CloudWatch Per ulteriori informazioni sulle modalità di risoluzione di questo problema, consulta la sezione [Analisi dell'applicazione](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#instrument-the-application).

Lo snippet di codice si trova nel tag `<head>` di un file HTML e installa il client Web scaricando il client Web e quindi configurandolo per l'applicazione che sta monitorando. Lo snippet è una funzione autoesecuzione simile alla seguente. In questo esempio, il corpo della funzione dello snippet è stato omesso per la leggibilità.

```
<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 (Argomenti)
<a name="CloudWatch-RUM-configure-client-arguments"></a>

Lo snippet di codice accetta sei argomenti:
+ Uno spazio dei nomi per l'esecuzione di comandi sul client Web, ad esempio`'cwr'`
+ L'ID del monitor dell'app, ad esempio `'00000000-0000-0000-0000-000000000000'`
+ Versione dell'applicazione, come `'1.0.0'`
+ La AWS regione del monitor dell'app, ad esempio `'us-west-2'`
+ L'URL del client Web, come `'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js'`
+ Opzioni di configurazione specifiche dell'applicazione. Per ulteriori informazioni, consulta la sezione seguente.

## Ignorare errori
<a name="CloudWatch-RUM-configure-ignore-errors"></a>

Il client web CloudWatch RUM ascolta tutti i tipi di errori che si verificano nelle applicazioni. Se l'applicazione emette JavaScript errori che non desiderate visualizzare nella dashboard CloudWatch RUM, potete configurare il client web CloudWatch RUM per filtrare questi errori in modo da visualizzare solo gli eventi di errore pertinenti sulla dashboard CloudWatch RUM. Ad esempio, potreste scegliere di non visualizzare alcuni JavaScript errori nella dashboard perché avete già identificato una soluzione e il volume di questi errori maschera altri errori. È possibile anche ignorare gli errori che non si possono correggere perché appartenenti a una libreria di proprietà di terze parti.

Per ulteriori informazioni su come utilizzare il client Web per filtrare JavaScript errori specifici, consulta l'esempio in [Errori nella documentazione](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md#errors) Github del client web.

## Opzioni di configurazione
<a name="CloudWatch-RUM-configure-options"></a>

Per informazioni sulle opzioni di configurazione disponibili per il client web CloudWatch RUM, consultate la documentazione del client [web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md)

# Abilitazione della riduzione delle tracce dello stack di JavaScript errori
<a name="CloudWatch-RUM-JavaScriptStackTraceSourceMaps"></a>

Quando il codice JavaScript sorgente dell'applicazione web viene minimizzato, le tracce dello stack di errori possono essere difficili da leggere. Puoi abilitare l'unminificazione delle tracce dello stack caricando le tue mappe di origine su Amazon S3. CloudWatch RUM recupererà le mappe di origine per mappare i numeri di riga e colonna del codice sorgente minimizzato al codice sorgente originale non minimizzato. Ciò migliorerà la leggibilità delle tracce di stack degli errori e aiuterà a identificare la posizione dell'errore nel codice sorgente originale. 

## Requisiti e sintassi
<a name="CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps"></a>

Le mappe di origine sono fondamentali per il debug e il monitoraggio dei problemi nelle applicazioni web nelle diverse versioni. Assicurati che ogni versione dell'applicazione web abbia una mappa di origine unica. Ogni versione deve avere il proprio ReleaseID univoco. Un ReleaseID deve essere una stringa di lunghezza compresa tra 1 e 200 caratteri e può contenere solo lettere, numeri, caratteri di sottolineatura, trattini, due punti, barre oblique e punti. Per aggiungere i metadati `releaseId` as agli eventi RUM, configura il client web RUM. CloudWatch 

Le mappe di origine dovrebbero essere semplici file JSON che seguono la struttura definita dalla [specifica Source Map V3](https://sourcemaps.info/spec.html). I campi obbligatori sono: `version`, `file`, `sources`, `names` e `mappings`.

Assicurati che la dimensione di ogni mappa di origine non superi il limite di 50 MB. Inoltre, il servizio RUM recupererà solo fino a 50 MB di mappe di origine per ciascuna traccia di stack. Se necessario, suddividi il codice sorgente in più blocchi più piccoli. Per ulteriori informazioni, consulta [Suddivisione del codice con WebpackJS](https://webpack.js.org/guides/code-splitting/).

**Topics**
+ [Requisiti e sintassi](#CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps)
+ [Configurazione della policy delle risorse del bucket Amazon S3 per consentire l'accesso al servizio RUM](#CloudWatch-RUM-ConfigureS3)
+ [Caricamento delle mappe di origine](#CloudWatch-RUM-UploadSourceMaps)
+ [Configura ReleaseID nel tuo client web RUM CloudWatch](#CloudWatch-RUM-ConfigureRumID)
+ [Abilitazione del monitor dell'app CloudWatch RUM per minimizzare le tracce dello stack JavaScript](#CloudWatch-RUM-unminifyjavascript)
+ [Visualizzazione delle tracce di stack deminificate nella console RUM](#CloudWatch-RUM-viewunminifiedstacktraces)
+ [Visualizzazione delle tracce di stack non minimizzate nei log CloudWatch](#CloudWatch-RUM-viewunminifiedstacktracesCWL)
+ [Risoluzione dei problemi con le mappe di origine](#CloudWatch-RUM-troubleshootsourcemaps)

## Configurazione della policy delle risorse del bucket Amazon S3 per consentire l'accesso al servizio RUM
<a name="CloudWatch-RUM-ConfigureS3"></a>

Assicurati che il bucket Amazon S3 si trovi nella stessa regione del tuo RUM AppMonitor. Configura il tuo bucket Amazon S3 per consentire l'accesso al servizio RUM per il recupero dei file delle mappe di origine. Includi le chiavi di contesto delle condizioni globali `aws:SourceArn` e `aws:SourceAccount` per limitare le autorizzazioni del servizio alla risorsa. Questo è il modo più efficace per proteggersi dal [problema di deputy confused](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).

L'esempio seguente mostra il modo in cui puoi utilizzare le chiavi di contesto delle condizioni globali `aws:SourceArn` e `aws:SourceAccount` in Amazon S3 per prevenire il problema del confused deputy.

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

****  

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

------

Se utilizzi AWS KMS chiavi per crittografare i dati, assicurati che la politica delle risorse della chiave sia configurata in modo simile in modo da includere le chiavi di contesto della `aws:SourceArn` condizione `aws:SourceAccount` globale per consentire al servizio RUM di accedere al servizio RUM per utilizzare le chiavi per recuperare i file della mappa di origine.

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

------

## Caricamento delle mappe di origine
<a name="CloudWatch-RUM-UploadSourceMaps"></a>

Configura il tuo JavaScript pacchetto per generare mappe di origine durante la minificazione. Quando create l'applicazione, il bundle creerà una directory (ad esempio, dist) contenente JavaScript i file minimizzati e le relative mappe di origine. Un esempio è fornito di seguito.

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

Carica i file delle mappe di origine nel tuo bucket Amazon S3. I file dovrebbero trovarsi in una cartella con il `releaseId` come nome. Ad esempio, se il nome del mio bucket è `my-application-source-maps` e il `releaseId` è 2.0.0, il file della mappa di origine si trova nella seguente posizione:

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

Per automatizzare il caricamento delle mappe di origine, puoi creare il seguente script bash ed eseguirlo come parte del processo di compilazione.

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

## Configura ReleaseID nel tuo client web RUM CloudWatch
<a name="CloudWatch-RUM-ConfigureRumID"></a>

CloudWatch RUM utilizza il file configurato `releaseId` per determinare la cartella in cui recuperare i file della mappa di origine. Assegna al `releaseId` lo stesso nome della cartella dei file della mappa di origine. Se hai usato lo script bash fornito sopra o uno simile, lo script `releaseId` configurato nello script dovrebbe essere lo stesso di quello configurato nel tuo client web CloudWatch RUM. È necessario utilizzare la versione 1.21.0 o successiva del 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
}
```

## Abilitazione del monitor dell'app CloudWatch RUM per minimizzare le tracce dello stack JavaScript
<a name="CloudWatch-RUM-unminifyjavascript"></a>

Per minimizzare le tracce JavaScript dello stack, imposta lo stato del monitor dell'app su. SourceMap `ENABLED` Fornisci l'URI di Amazon S3 al bucket o alla cartella contenente tutte le mappe di origine per il monitor dell'app.

Quando si archiviano le mappe di origine direttamente nel bucket principale (non in una sottocartella), l'URI di Amazon S3 deve essere formattato come `Amazon S3://BUCKET_NAME`. In questo caso, i file delle mappe di origine devono trovarsi nella seguente posizione.

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

Quando una directory secondaria è la directory root, l'URI di Amazon S3 deve essere formattato come `Amazon S3://BUCKET_NAME/DIRECTORY`. In questo caso, i file delle mappe di origine devono trovarsi nella seguente posizione.

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

## Visualizzazione delle tracce di stack deminificate nella console RUM
<a name="CloudWatch-RUM-viewunminifiedstacktraces"></a>

Dopo aver caricato le mappe di origine su Amazon S3, aver abilitato le mappe di origine sul monitor dell'app RUM e aver distribuito l'applicazione Web con `releaseId` il client Web configurato nel CloudWatch RUM, **seleziona** Eventi nella console RUM. Questa scheda mostra i dati grezzi degli eventi RUM. Filtra in base al tipo di evento di errore JS e visualizza l'ultimo evento di errore JS. Vedrai la traccia di stack deminificata nel nuovo campo `event_details.unminifiedStack` per gli eventi inseriti dopo l'attivazione della funzionalità.

## Visualizzazione delle tracce di stack non minimizzate nei log CloudWatch
<a name="CloudWatch-RUM-viewunminifiedstacktracesCWL"></a>

**Abilita l'archiviazione degli eventi RUM nei CloudWatch registri attivando l'archiviazione dei dati.** Una volta abilitato, puoi cercare nel nuovo campo **event\$1details.unminifiedStack**. Ciò consente di analizzare le tendenze e mettere in relazione i problemi tra più sessioni utilizzando le query di CloudWatch Logs.

## Risoluzione dei problemi con le mappe di origine
<a name="CloudWatch-RUM-troubleshootsourcemaps"></a>

CloudWatch RUM fornisce metriche pronte all'uso per risolvere i problemi di configurazione della mappa di origine. Tali parametri sono pubblicati nel parametro spazio dei nomi denominato `AWS/RUM`. Le metriche seguenti sono pubblicate con una dimensione application\$1name. Il valore di questa dimensione è il nome del monitor dell'app. Le metriche sono anche pubblicate con una dimensione `aws:releaseId`. Il valore di questa dimensione è quello `releaseId` associato all'evento di errore. JavaScript 


| MetricName | Unità | Description | 
| --- | --- | --- | 
|  UnminifyLineFailureCount  |  Conteggio  |  Il conteggio delle righe della traccia di stack nell'evento di errore JS che non è stato deminificato. Ulteriori dettagli sull'errore verranno aggiunti alla riga specifica che ha avuto esito negativo nel campo event\$1details.unminifiedStack.  | 
|  UnminifyLineSuccessCount  |  Conteggio  | Il conteggio delle righe della traccia di stack nell'evento di errore JS che sono state deminificate correttamente. | 
| UnminifyEventFailureCount | Conteggio | Il conteggio degli eventi di errore JS per i quali non è stata deminificata alcuna riga. Ulteriori dettagli sull'errore verranno aggiunti nel campo event\$1details.unminifiedStack. | 
| UnminifyEventSuccessCount | Conteggio | Il conteggio degli eventi di errore JS che sono riusciti a rendere deminificata almeno una riga della traccia di stack. | 

CloudWatch RUM potrebbe non riuscire a deminimizzare una riga nello stack trace per vari motivi, tra cui, a titolo esemplificativo ma non esaustivo:
+ Impossibile recuperare il file della mappa di origine corrispondente a causa di problemi di autorizzazione. Assicurati che la policy delle risorse del bucket sia configurata correttamente.
+ Il file della mappa di origine corrispondente non esiste. Assicurati che i file della mappa di origine siano stati caricati nel bucket o nella cartella corretti con lo stesso nome del ReleaseID configurato nel tuo client web RUM. CloudWatch 
+ Il file della mappa di origine corrispondente è troppo grande. Suddividi il codice sorgente in blocchi più piccoli.
+ Sono già stati recuperati 50 MB di file di mappa sorgente per la traccia dello stack. Riduci la lunghezza della traccia di stack poiché 50 MB è una limitazione sul lato del servizio.
+ La mappa di origine non è valida e non può essere indicizzata. Assicurati che la mappa di origine sia un semplice JSON che segue la struttura definita dalla specifica Source Map V3 e includa i seguenti campi: versione, file, origini, nomi, mappature.
+ La mappa di origine non è riuscita a mappare il codice sorgente minificato alla traccia di stack deminificata. Assicurati che la mappa di origine sia quella corretta per il ReleaseID specificato.

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

Questa sezione illustra le strategie per l'utilizzo di CloudWatch RUM con applicazioni in diverse regioni.

## La mia applicazione è distribuita in più regioni AWS
<a name="CloudWatch-RUM-Regionalization-multiple"></a>

Se la tua applicazione è distribuita in più AWS regioni, hai tre opzioni:
+ Implementare un monitor di app in un'unica Eegione, in un unico account, che funziona in tutte le Regioni.
+ Implementare monitor di app separati per ogni Regione, in account unici.
+ Implementare monitor di app separati per ogni Regione, tutti in un account.

Il vantaggio dell'utilizzo di un unico app monitor è che tutti i dati saranno centralizzati in un'unica visualizzazione e tutti i log verranno scritti nello stesso gruppo di log in Logs. CloudWatch Con un unico monitor di app c'è una piccola latenza aggiuntiva per le richieste e un unico punto di errore.

L'utilizzo di più monitor per app rimuove il singolo punto di errore, ma impedisce che tutti i dati vengano combinati in un'unica visualizzazione.

### CloudWatch RUM non è stato avviato in alcune regioni in cui è distribuita la mia applicazione
<a name="CloudWatch-RUM-Regionalization-notavailable"></a>

CloudWatch RUM viene lanciato in molte regioni e ha un'ampia copertura geografica. Configurando il CloudWatch RUM nelle regioni in cui è disponibile, è possibile ottenere i vantaggi. Gli utenti finali possono essere ovunque e avere comunque le sessioni incluse se hai configurato un monitor di app nella regione a cui si connettono.

Tuttavia, CloudWatch RUM non è ancora stato lanciato in nessuna regione della Cina. Non è possibile inviare dati a CloudWatch RUM da queste regioni.

# Utilizzo dei gruppi di pagine
<a name="CloudWatch-RUM-page-groups"></a>

Utilizzare i gruppi di pagine per associare tra loro diverse pagine dell'applicazione in modo da poter visualizzare analisi aggregate per gruppi di pagine. Ad esempio, è possibile visualizzare i tempi di caricamento delle pagine aggregati di tutte le pagine di destinazione. 

Puoi inserire le pagine in gruppi di pagine aggiungendo uno o più tag agli eventi di visualizzazione delle pagine nel client web CloudWatch RUM. Negli esempi seguenti la pagina `/home` viene inserita nei gruppi di pagine denominati `en` e `landing`.

**Esempio di script incorporato**

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

**JavaScript esempio di modulo**

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

**Nota**  
I gruppi di pagine hanno lo scopo di facilitare l'aggregazione dell'analisi su pagine diverse. Per informazioni su come definire e manipolare gli `pageIds` per l'applicazione, consulta **Registrazione manuale delle visualizzazioni di pagina** in [Modifica dello snippet di codice per configurare il client web CloudWatch RUM (opzionale)](CloudWatch-RUM-modify-snippet.md).

# Specifica di metadati personalizzati
<a name="CloudWatch-RUM-custom-metadata"></a>

CloudWatch RUM allega dati aggiuntivi a ciascun evento come metadati. I metadati degli eventi sono costituiti da attributi sotto forma di coppie chiave-valore. È possibile utilizzare questi attributi per cercare o filtrare gli eventi nella console CloudWatch RUM. Per impostazione predefinita, CloudWatch RUM crea alcuni metadati per voi. Per ulteriori informazioni sui metadati predefiniti, consulta [Metadati degli eventi RUM](CloudWatch-RUM-datacollected.md#CloudWatch-RUM-datacollected-metadata).

È inoltre possibile utilizzare il client web CloudWatch RUM per aggiungere metadati personalizzati agli eventi CloudWatch RUM. I metadati personalizzati possono includere attributi di sessione e attributi di pagina.

Per aggiungere metadati personalizzati, è necessario utilizzare la versione 1.10.0 o successiva del CloudWatch client web RUM.

## Requisiti e sintassi
<a name="CloudWatch-RUM-custom-metadata-syntax"></a>

Ogni evento può includere fino a 10 attributi personalizzati nei metadati. I requisiti di sintassi per gli attributi personalizzati sono i seguenti:
+ **Chiavi**
  + Massimo 128 caratteri
  + Può includere caratteri alfanumerici, due punti (:) e caratteri di sottolineatura (\$1)
  + Non può iniziare con `aws:`.
  + Non può essere composto interamente da nessuna delle parole chiave riservate elencate nella sezione seguente. È possibile utilizzare queste parole chiave come parte di un nome chiave più lungo.
+ **Valori**
  + Massimo 256 caratteri
  + Deve essere costituito da stringhe, numeri o valori booleani

**Parole chiave riservate**

Non puoi utilizzare le seguenti parole chiave riservate come nomi chiave completi. Puoi utilizzare le seguenti parole chiave come parte di un nome chiave più lungo, ad esempio `applicationVersion`.
+ `browserLanguage`
+ `browserName`
+ `browserVersion`
+ `countryCode`
+ `deviceType`
+ `domain`
+ `interaction`
+ `osName`
+ `osVersion`
+ `pageId`
+ `pageTags`
+ `pageTitle`
+ `pageUrl`
+ `parentPageId`
+ `platformType`
+ `referrerUrl`
+ `subdivisionCode`
+ `title`
+ `url`
+ `version`

**Nota**  
CloudWatch RUM rimuove gli attributi personalizzati dagli eventi RUM se un attributo include una chiave o un valore non valido o se è già stato raggiunto il limite di 10 attributi personalizzati per evento. 

## Aggiunta di attributi di sessione
<a name="CloudWatch-RUM-session-attributes"></a>

Quando configuri degli attributi di sessione personalizzati, questi vengono aggiunti a tutti gli eventi di una sessione. È possibile configurare gli attributi di sessione durante l'inizializzazione del client Web CloudWatch RUM o in fase di esecuzione utilizzando il `addSessionAttributes` comando.

Ad esempio, puoi aggiungere la versione dell'applicazione come attributo di sessione. Quindi, nella console CloudWatch RUM, puoi filtrare gli errori per versione per scoprire se un tasso di errore maggiore è associato a una particolare versione dell'applicazione. 

**Aggiunta di un attributo di sessione all'inizializzazione (esempio NPM)**

La sezione del codice in grassetto aggiunge l'attributo di sessione.

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

**Aggiunta di un attributo di sessione in fase di runtime (esempio NPM)**

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

**Aggiunta di un attributo di sessione in fase di inizializzazione (esempio di script incorporato)**

La sezione del codice in grassetto aggiunge l'attributo di sessione.

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

**Aggiunta di un attributo di sessione in fase di runtime (esempio di script incorporato)**

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

## Aggiunta di attributi di pagina
<a name="CloudWatch-RUM-page-attributes"></a>

Quando configuri gli attributi di pagina personalizzati, questi vengono aggiunti a tutti gli eventi della pagina corrente. È possibile configurare gli attributi di pagina durante l'inizializzazione del client Web CloudWatch RUM o in fase di esecuzione utilizzando il `recordPageView` comando.

Ad esempio, puoi aggiungere il modello di pagina come attributo di pagina. Quindi, nella console CloudWatch RUM, è possibile filtrare gli errori in base ai modelli di pagina per scoprire se un tasso di errore maggiore è associato a un particolare modello di pagina dell'applicazione. 

**Aggiunta di un attributo di pagina in fase di inizializzazione (esempio NPM)**

La sezione del codice in grassetto aggiunge l'attributo di pagina.

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

**Aggiunta di un attributo di pagina in fase di runtime (esempio NPM)**

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

**Aggiunta di un attributo di pagina in fase di inizializzazione (esempio di script incorporato)**

La sezione del codice in grassetto aggiunge l'attributo di pagina.

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

**Aggiunta di un attributo di pagina in fase di runtime (esempio di script incorporato)**

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

## Filtraggio in base agli attributi dei metadati nella console
<a name="CloudWatch-RUM-custom-attiributes-console"></a>

Per filtrare le visualizzazioni nella console CloudWatch RUM con qualsiasi attributo di metadati integrato o personalizzato, utilizza la barra di ricerca. Nella barra di ricerca, puoi specificare fino a 20 termini di filtro sotto forma di **chiave=valore** da applicare alle visualizzazioni. Ad esempio, per filtrare i dati solo per il browser Chrome, puoi aggiungere il termine di ricerca **browserName=Chrome**.

Per impostazione predefinita, la console CloudWatch RUM recupera i 100 attributi, chiavi e valori più comuni da visualizzare nel menu a discesa nella barra di ricerca. Per aggiungere altri attributi di metadati come termini di filtro, inserisci la chiave e il valore completi dell'attributo nella barra di ricerca. 

Un filtro può includere fino a 20 termini e puoi salvare fino a 20 filtri per monitorare l'app. Quando salvi un filtro, questo viene salvato nel menu a discesa **Saved filters** (Filtri salvati). Puoi anche eliminare i filtri salvati. 

# Invio di eventi personalizzati
<a name="CloudWatch-RUM-custom-events"></a>

CloudWatch RUM registra e inserisce gli eventi elencati in[Informazioni raccolte dal client web CloudWatch RUM](CloudWatch-RUM-datacollected.md). Se si utilizza la versione 1.12.0 o successiva del client web CloudWatch RUM, è possibile definire, registrare e inviare eventi personalizzati aggiuntivi. Puoi stabilire il nome del tipo di evento e i dati da inviare per ogni tipo di evento che definisci. Ogni payload di eventi personalizzato può contenere fino a 6 KB.

Gli eventi personalizzati vengono inseriti solo se sono stati abilitati nel monitoraggio dell'app. Per aggiornare le impostazioni di configurazione dell'app monitor, utilizza la console CloudWatch RUM o l'[UpdateAppMonitor](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_UpdateAppMonitor.html)API. 

Dopo aver abilitato gli eventi personalizzati e aver definito e inviato gli eventi personalizzati, puoi effettuare una ricerca. Per cercarle, usa la scheda **Eventi** nella console CloudWatch RUM. Effettua la ricerca utilizzando il tipo di evento.

## Requisiti e sintassi
<a name="CloudWatch-RUM-custom-event-syntax"></a>

Gli eventi personalizzati sono costituiti da un tipo di evento e dai relativi dettagli. I parametri sono i seguenti:
+ **Tipo di evento**
  + Questo valore può essere il **tipo** o il **nome** dell'evento. Ad esempio, il tipo di evento integrato CloudWatch RUM chiamato **JsError**ha un tipo di evento di`com.amazon.rum.js_error_event`.
  + Deve contenere da 1 a 256 caratteri.
  + Può essere una combinazione di caratteri alfanumerici, caratteri di sottolineatura, trattini e punti.
+ **Dettagli dell'evento**
  + Contiene i dati effettivi che si desidera registrare in CloudWatch RUM.
  + Deve essere un oggetto composto da campi e valori.

## Esempi di registrazione di eventi personalizzati
<a name="CloudWatch-RUM-custom-event-examples"></a>

Esistono due modi per registrare eventi personalizzati nel client web CloudWatch RUM. 
+ Utilizza l'`recordEvent`API del client web CloudWatch RUM.
+ Utilizza un plug-in personalizzato.

**Invio di un evento personalizzato tramite l'API `recordEvent` (esempio NPM)**

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

**Invio di un evento personalizzato tramite l'API `recordEvent` (esempio di script incorporato)**

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

**Esempio di invio di un evento personalizzato tramite un plug-in personalizzato**

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

# Visualizzazione della dashboard CloudWatch RUM
<a name="CloudWatch-RUM-view-data"></a>

CloudWatch RUM ti aiuta a raccogliere dati dalle sessioni utente sulle prestazioni dell'applicazione, inclusi i tempi di caricamento, il punteggio Apdex, le informazioni sul dispositivo, la geolocalizzazione delle sessioni utente e le sessioni con errori. Tutte queste informazioni vengono visualizzate in un pannello di controllo.

Per visualizzare la dashboard RUM:

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

La console RUM mostra una visualizzazione a elenco di tutti i monitor delle app. La colonna **Piattaforma** indica se ogni app monitor è per applicazioni Web, Android o iOS. Seleziona un monitor dell'app per accedere alle visualizzazioni dettagliate con **le schede Prestazioni**, **Errori**, **Sessioni**, **Metriche** e **Configurazione**.

## Dashboard dell'applicazione Web
<a name="CloudWatch-RUM-web-dashboard"></a>

Quando selezioni il monitor di un'applicazione web, vedrai le seguenti schede:
+ La scheda **Prestazioni** visualizza le informazioni sulle prestazioni della pagina, inclusi tempi di caricamento, informazioni sulle richieste, parametri vitali web e i dati sul caricamento della pagina nel tempo. Questa visualizzazione presenta grafici interattivi di web vitals in cui puoi vedere i diversi valori percentili dei principali web vitals per le tue pagine e scegliere i punti dati sul grafico per visualizzare gli eventi associati acquisiti da RUM. CloudWatch Da lì, puoi esplorare altri eventi relativi al picco di una metrica o visualizzare i dettagli della pagina per un evento selezionato al fine di identificare condizioni specifiche che causano problemi di prestazioni.

  In questa scheda puoi anche alternare la visualizzazione tra **Caricamenti della pagina**, **Richieste** e **Posizione** per visualizzare maggiori dettagli sulle prestazioni della pagina.
+ La scheda **Errori** visualizza le informazioni sugli errori Javascript, incluso il messaggio di errore più frequentemente visualizzato da utenti, dispositivi e browser con il maggior numero di errori. Questa visualizzazione include un istogramma degli errori e una visualizzazione a elenco degli errori. È possibile filtrare l'elenco degli errori per dettagli dell'utente e dettagli dell'evento. Scegli un messaggio di errore per visualizzare maggiori dettagli.
+ La scheda **Richieste HTTP** mostra le informazioni sulla richiesta HTTP, tra cui l'URL della richiesta con il maggior numero di errori e i dispositivi e i browser con il maggior numero di errori. Questa scheda include un istogramma delle richieste, una vista a elenco delle richieste e una vista a elenco degli errori di rete. È possibile filtrare gli elenchi per dettagli dell'utente e dettagli dell'evento. Scegliete un codice di risposta o un messaggio di errore per visualizzare maggiori dettagli rispettivamente sulla richiesta o sull'errore di rete.
+ La scheda **Sessioni** mostra i parametri della sessione. Questa scheda include un istogramma degli eventi di inizio della sessione e una vista a elenco delle sessioni. È possibile filtrare l'elenco delle sessioni per tipo di evento, dettagli utente e dettagli dell'evento. Scegli un **sessionId** per visualizzare maggiori dettagli su una sessione.
+ La scheda **Eventi** mostra un istogramma degli eventi RUM e una vista a elenco degli eventi. È possibile filtrare l'elenco delle sessioni per tipo di evento, dettagli dell'utente e dettagli dell'evento. Scegli un evento RUM per visualizzare l'evento non elaborato.
+ La scheda **Browser e dispositivi** visualizza informazioni come le prestazioni e l'utilizzo di diversi browser e dispositivi per accedere all'applicazione. Questa vista include controlli per alternare la visualizzazione tra **Browser** e **Dispositivi**.

  Se si restringe l'ambito a un singolo browser, vengono visualizzati i dati suddivisi per versione del browser.
+ La scheda**Percorso dell'utente** visualizza i percorsi utilizzati dai clienti per navigare nell'applicazione. È possibile vedere dove i clienti entrano nell'applicazione e da quale pagina escono dall'applicazione. È possibile anche vedere i percorsi che seguono e la percentuale di clienti che seguono tali percorsi. È possibile fermarsi su un nodo per ottenere ulteriori dettagli su quella pagina. È possibile scegliere un singolo percorso per evidenziare le connessioni per facilitare la visualizzazione.
+  La scheda **Metriche** mostra tutte le CloudWatch metriche predefinite pubblicate dal monitor dell'app, tra cui dati vitali web relativi alle prestazioni, metriche di errore (JavaScript errori, errori/guasti HTTP), volume, flusso utente e metriche apdex. Se hai creato metriche estese per la tua applicazione, la scheda include anche un sottoinsieme di queste metriche nella sezione metriche estese. Questo sottoinsieme include metriche di tipo, http4xxCount PageViewCount, PerformanceNavigationDuration http5xxCount e. JsErrorCount La dashboard mostra tre variazioni metriche per tipo di metrica. Poiché si tratta di CloudWatch metriche, puoi anche esportare questa scheda nella tua dashboard utilizzando l'opzione **Aggiungi alla dashboard** e aggiornarla per includere più metriche. 

(Facoltativo) In una qualsiasi delle prime sei schede, è possibile scegliere il pulsante **Pagine** e selezionare una pagina o un gruppo di pagine dall'elenco. Ciò riduce i dati visualizzati a una singola pagina o un gruppo di pagine dell'applicazione. È inoltre possibile contrassegnare le pagine a gruppi di pagine dell'elenco come preferite.

## Dashboard dell'applicazione mobile
<a name="CloudWatch-RUM-mobile-dashboard"></a>

Quando selezioni un monitor per applicazioni mobili, vedrai le seguenti schede:
+ La scheda **Prestazioni** fornisce informazioni dettagliate sulle prestazioni dell'applicazione mobile, inclusi i tempi di caricamento dello schermo, i tempi di avvio delle app (a freddo e caldo), le metriche delle prestazioni e i punteggi Apdex nel tempo. La visualizzazione dettagliata suddivide le prestazioni per nomi di schermata, versioni del sistema operativo, versioni delle app, dispositivi e paesi. **Facendo clic sul tempo di caricamento della schermata, sull'ora di avvio dell'app o sul datapoint della posizione nel grafico, si aprirà il pannello di diagnostica sulla destra che fornisce ulteriori informazioni relative al datapoint, tra cui le sessioni correlate più recenti e i collegamenti alla scheda Sessioni per la risoluzione dei problemi.**

  **In questa scheda puoi anche alternare la visualizzazione tra **Caricamenti dello schermo**, **Avvio di app e Posizione per visualizzare maggiori dettagli sulle prestazioni delle** applicazioni.**

  La scheda include anche il punteggio dell'indice di prestazioni dell'applicazione (Apdex) che indica il livello di soddisfazione degli utenti finali. I punteggi variano da 0 (meno soddisfatti) a 1 (i più soddisfatti). I punteggi si basano solo sulle prestazioni dell'applicazione. Per ulteriori informazioni sui punteggi Apdex, consulta [In CloudWatch che modo RUM imposta i punteggi di Apdex](#CloudWatch-RUM-apdex).
+ La scheda **Errori** suddivide i problemi delle applicazioni in tre categorie: errori di rete, arresti anomali e blocchi ANRs (Android) /app (iOS). La scheda **Errori di rete** presenta un grafico a linee che mostra la latenza di rete, gli errori del client (codice di stato 4xx) e gli errori del server (codice di stato 5xx). Facendo clic su un punto dati per una di queste righe del grafico si aprirà il pannello di diagnostica. La tabella in basso elenca le 100 rotte di rete più comuni. Facendo clic su un pulsante radio, il grafico a linee verrà filtrato in base alla rotta di rete selezionata.

  Analogamente, le schede **Crashes** e **ANRs/App Hangs** mostrano una serie di linee per il conteggio di ogni errore, e queste non sono trattabili. La tabella in basso mostra il top crash message o Hang stack trace più comune. ANR/App Facendo clic su un pulsante di opzione si filtrerà il grafico, mentre facendo clic sul messaggio di errore verrà visualizzata la traccia completa dello stack.
+ La scheda **Sessioni** mostra una tabella che elenca tutte le sessioni in ordine cronologico decrescente. Nella parte inferiore, una visualizzazione a cascata mostra tutta la telemetria per la sessione selezionata, aiutandoti a tenere traccia delle interazioni degli utenti e a identificare i problemi di prestazioni. Ogni riga della cascata può essere selezionata per aprire il pannello di diagnostica. Per le richieste HTTP, vedrai un **TraceID** che si collega alla console Traces.

  Per le richieste HTTP con codici di stato diversi da 2xx, arresti anomali o ANRs (Android) /App Hangs (iOS), il pannello di diagnostica include **una** scheda Exception con la traccia dello stack. Il pulsante **Visualizza** nella cascata consente di accedere rapidamente a queste informazioni.
+ La scheda **Metriche** mostra tutte le CloudWatch metriche predefinite pubblicate dal monitor dell'app, incluse le metriche delle prestazioni (tempi di caricamento dello schermo, tempi di avvio a freddo dell'app), le metriche di errore (arresti anomali, blocchi, ANRs/App HTTP e. errors/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 WarmLaunchTime La dashboard mostra tre variazioni metriche per tipo di metrica. Poiché si tratta di CloudWatch metriche, puoi anche esportare questa scheda nella tua dashboard utilizzando l'opzione **Aggiungi alla dashboard** e aggiornarla per includere più metriche.
+ La scheda **Configurazione** consente di accedere alle impostazioni generali e ai dettagli di configurazione del monitor dell'app. Puoi anche accedere alla scheda **Frammenti di codice** che contiene le istruzioni per strumentare la tua applicazione mobile con l'SDK ADOT, comprese le opzioni di strumentazione Manual e Zero-Code.

### In CloudWatch che modo RUM imposta i punteggi di Apdex
<a name="CloudWatch-RUM-apdex"></a>

Apdex (Indice delle prestazioni dell'applicazione) è uno standard aperto che definisce un metodo per il report, il benchmark e il tempo di risposta delle applicazioni. Un punteggio Apdex aiuta a comprendere e identificare l'impatto sulle prestazioni delle applicazioni nel tempo.

Il punteggio Apdex indica il livello di soddisfazione degli utenti finali. I punteggi variano da 0 (meno soddisfatti) a 1 (i più soddisfatti). I punteggi si basano solo sulle prestazioni dell'applicazione. Agli utenti non viene chiesto di valutare l'applicazione.

Ogni singolo punteggio Apdex rientra in una delle tre soglie. In base alla soglia Apdex e al tempo di risposta effettivo dell'applicazione, esistono tre tipi di prestazioni, come segue:
+ **Soddisfatto**: il tempo di risposta effettivo dell'applicazione è inferiore o uguale alla soglia Apdex. Per CloudWatch RUM, questa soglia è pari o inferiore a 2000 ms.
+ **Tollerabile**: il tempo di risposta effettivo dell'applicazione è superiore alla soglia Apdex, ma inferiore o uguale a quattro volte la soglia Apdex. Per CloudWatch RUM, questo intervallo è compreso tra 2000 e 8000 ms.
+ **Frustrante**: il tempo di risposta effettivo dell'applicazione è superiore a quattro volte la soglia Apdex. Per CloudWatch RUM, questo intervallo è superiore a 8000 ms.

Il punteggio totale di 0-1 Apdex viene calcolato utilizzando la seguente formula:

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

# CloudWatch metriche che puoi raccogliere con RUM CloudWatch
<a name="CloudWatch-RUM-metrics"></a>

Le tabelle in questa sezione elencano le metriche raccolte automaticamente con CloudWatch RUM dalle applicazioni Web, dalle applicazioni mobili o da entrambe. Puoi visualizzare queste metriche nella CloudWatch console. Per ulteriori informazioni, consulta [Visualizzazione di parametri disponibili](viewing_metrics_with_cloudwatch.md).

Facoltativamente, puoi anche inviare metriche estese a. CloudWatch Per ulteriori informazioni, consulta [Parametri estesi](CloudWatch-RUM-custom-and-extended-metrics.md#CloudWatch-RUM-vended-metrics).

Tali parametri sono pubblicati nel parametro spazio dei nomi denominato `AWS/RUM`. Tutti i parametri seguenti sono pubblicati con una dimensione `application_name`. Il valore di questa dimensione è il nome del monitor dell'app. Alcune metriche vengono pubblicate anche con dimensioni aggiuntive, come elencato nella tabella seguente.


**Metriche Web**  

| Metrica | Unità | Description | 
| --- | --- | --- | 
|  `HttpStatusCodeCount` |  Conteggio  |  Il conteggio delle risposte HTTP nell'applicazione, in base al codice di stato della risposta. Dimensioni aggiuntive: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `Http4xxCount` |  Conteggio  |  Il conteggio delle risposte HTTP nell'applicazione, con codice di stato della risposta 4xx. Questi vengono calcolati in base agli eventi RUM `http_event` che generano codici 4xx.  | 
|  `Http4xxCountPerSession` |  Conteggio  |  Il conteggio delle risposte HTTP in una sessione, con codice di stato della risposta 4xx. Questi vengono calcolati in base agli eventi RUM `http_event` che generano codici 4xx.  | 
|  `Http4xxCountPerPageView` |  Conteggio  |  Il conteggio delle risposte HTTP in una revisione di pagina, con codice di stato della risposta 4xx. Questi vengono calcolati in base agli eventi RUM `http_event` che generano codici 4xx.  | 
|  `Http5xxCount` |  Conteggio  |  Il conteggio delle risposte HTTP nell'applicazione, con codice di stato della risposta 5xx. Questi vengono calcolati in base agli eventi RUM `http_event` che generano codici 5xx.  | 
|  `Http5xxCountPerSession` |  Conteggio  |  Il conteggio delle risposte HTTP nella sessione, con codice di stato della risposta 5xx. Questi vengono calcolati in base agli eventi RUM `http_event` che generano codici 5xx.  | 
|  `Http5xxCountPerPageView` |  Conteggio  |  Il conteggio delle risposte HTTP in una revisione di pagina, con codice di stato della risposta 5xx. Questi vengono calcolati in base agli eventi RUM `http_event` che generano codici 5xx.  | 
|  `JsErrorCount` |  Conteggio  |  Il numero di eventi di JavaScript errore inseriti.   | 
|  `JsErrorCountPerSession` |  Conteggio  |  Il numero di eventi di JavaScript errore inseriti in una sessione.  | 
|  `JsErrorCountPerPageView` |  Conteggio  |  Il numero di eventi di JavaScript errore inseriti in una revisione di pagina.  | 
|  `NavigationFrustratedTransaction` |  Conteggio  |  Il numero di eventi di navigazione con una `duration` superiore alla soglia critica, che è di 8000 ms. La durata degli eventi di navigazione è tracciata nel parametro `PerformanceNavigationDuration`.  | 
|  `NavigationSatisfiedTransaction` |  Conteggio  |  Il numero di eventi di navigazione con una `duration` inferiore all'obiettivo Apdex, che è di 2000 ms. La durata degli eventi di navigazione è tracciata nel parametro `PerformanceNavigationDuration`.  | 
|  `NavigationToleratedTransaction` |  Conteggio  |  Il numero di eventi di navigazione con una `duration` tra 2000 e 8000 ms. La durata degli eventi di navigazione è tracciata nel parametro `PerformanceNavigationDuration`.  | 
|  `PageViewCount` |  Conteggio  |  Il numero di eventi di visualizzazione della pagina acquisiti dal monitor dell'app. Questo viene calcolato contando gli eventi `page_view_event` di RUM.  | 
|  `PageViewCountPerSession` |  Conteggio  |  Il numero di eventi di visualizzazione della pagina in una sessione. | 
|  `PerformanceResourceDuration` |  Millisecondi  |  La `duration` di un evento della risorsa. Dimensioni aggiuntive: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `PerformanceNavigationDuration` |  Millisecondi  |  La `duration` di un evento di navigazione.  | 
|  `RumEventPayloadSize` |  Byte  |  La dimensione di ogni evento inserito da RUM. CloudWatch È possibile utilizzare anche la statistica `SampleCount` per questo parametro per monitorare il numero di eventi che un monitor app sta acquisendo.  | 
|  `SessionCount` |  Conteggio  |  Il numero di eventi di avvio della sessione acquisiti dal monitor dell'app. In altre parole,il numero di nuove sessioni avviate.  | 
|  `SessionDuration` |  Millisecondi  |  La durata di una sessione. Questi vengono calcolati in base al tempo che intercorre tra il primo e l'ultimo evento di una sessione.  | 
|  `TimeOnPage` |  Millisecondi  |  La durata della visualizzazione di una pagina. Questi valori vengono calcolati in base al tempo fino alla visualizzazione della pagina successiva, tranne per l'ultima pagina di una sessione, in cui si considera il tempo tra il primo e l'ultimo evento su quella pagina.  | 
|  `WebVitalsCumulativeLayoutShift` |  Nessuno  |  Tiene traccia del valore degli eventi cumulativi di spostamento del layout.  | 
|  `WebVitalsFirstInputDelay` |  Millisecondi  |  Tiene traccia del valore dei primi eventi di ritardo di input.  | 
|  `WebVitalsLargestContentfulPaint` |  Millisecondi  |  Monitora il valore degli eventi Largest Contentful Paint.  | 
|  `WebVitalsInteractionToNextPaint` |  Millisecondi  |  Tiene traccia del valore degli eventi di tipo Interaction to next paint.  | 

Puoi configurare metriche estese per la tua applicazione mobile per fornire dimensioni aggiuntive per l'analisi.


**Metriche mobili**  

| Metrica | Unità | Description | 
| --- | --- | --- | 
|  `ANRCount`  |  Conteggio  |  Solo per Android: il numero di incidenti ANR (Application Not Responding), che si verificano quando l'applicazione non risponde per più di 5 secondi, con conseguente arresto anomalo dell'applicazione.  | 
|  `AppHangCount`  |  Conteggio  |  Solo per iOS: il numero di volte in cui l'applicazione non risponde per più di 250 ms sul loop principale.  | 
|  `ColdAppLaunchFrustratedTransaction`  |  Conteggio  |  Il numero di lanci di app a freddo che hanno richiesto più di 8 secondi per essere completati, che probabilmente hanno causato frustrazione agli utenti.  | 
|  `ColdAppLaunchSatisfiedTransaction`  |  Conteggio  |  Il numero di lanci di app a freddo completati in meno di 2 secondi, che hanno fornito un'esperienza utente soddisfacente.  | 
|  `ColdAppLaunchToleratedTransaction`  |  Conteggio  |  Il numero di lanci di app a freddo che sono stati completati tra 2 e 8 secondi, che hanno fornito un'esperienza utente tollerabile, ma non ideale.  | 
|  `ColdLaunchTime`  |  Millisecondi  |  Tempo impiegato per avviare l'applicazione da uno stato terminato. Per Android: tempo intercorso tra l'applicazione e il `onCreate` completamento della creazione della prima attività. Per iOS: tempo compreso tra l'avvio dell'applicazione (determinato dal comando `sysctl` di avvio del processo) e il`didBecomeActiveNotification`.  | 
|  `CrashCount`  |  Conteggio  |  Il numero di chiusure impreviste dell'applicazione causate da eccezioni non gestite o dalla chiusura del sistema operativo. Per Android: arresti anomali dovuti a eccezioni non gestite o alla chiusura del sistema. Per iOS: arresti anomali dovuti a eccezioni non gestite, errori irreversibili o chiusura del sistema. I dati relativi agli arresti anomali vengono archiviati localmente e segnalati al successivo avvio dell'app.  | 
|  `DroppedEventsCount`  |  Conteggio  |  Il numero di eventi di registro che sono stati eliminati perché hanno superato il limite di dimensione massima di 30 KB per evento.  | 
|  `DroppedSpansCount`  |  Conteggio  |  Il numero di intervalli che sono stati eliminati perché hanno superato il limite di dimensione massima di 30 KB per intervallo.  | 
|  `Http4xxCount`  |  Conteggio  |  Registra il numero di errori del client HTTP riscontrati dall'applicazione Web o mobile durante le richieste HTTP.  | 
|  `Http5xxCount`  |  Conteggio  |  Registra il numero di errori del server HTTP riscontrati dall'applicazione Web o mobile durante le richieste HTTP.  | 
|  `LogPayloadSize`  |  Byte  |  La dimensione in byte dei dati di telemetria del registro inviati a RUM. CloudWatch  Puoi anche utilizzare la `SampleCount` statistica di questa metrica per monitorare il numero di eventi di registro che un monitor di app sta acquisendo.  | 
|  `NetworkLatency`  |  Millisecondi  |  Il tempo impiegato per il completamento delle richieste di rete, che misura il tempo di andata e ritorno dall'avvio della richiesta al completamento della risposta.  | 
|  `ScreenLoadCount`  |  Conteggio  |  Il numero totale di schermate caricate.  | 
|  `ScreenLoadToleratedTransaction`  |  Conteggio  |  Il numero di caricamenti dello schermo completati tra 2 e 8 secondi, che ha fornito un'esperienza utente tollerabile, ma non ideale.  | 
|  `SessionCount`  |  Conteggio  |  Il numero totale di sessioni utente uniche con l'applicazione. Una sessione inizia quando l'utente apre l'app e termina dopo 30 minuti di inattività o quando viene terminata esplicitamente.  | 
|  `SpanPayloadSize`  |  Byte  |  La dimensione in byte dei dati di telemetria span inviati a RUM. CloudWatch  Puoi anche utilizzare la `SampleCount` statistica di questa metrica per monitorare il numero di Span che un monitor di app sta acquisendo.  | 
|  `WarmAppLaunchFrustratedTransaction`  |  Conteggio  |  Il numero di avvii rapidi di app che hanno richiesto più di 8 secondi per essere completati, che probabilmente hanno causato frustrazione agli utenti.  | 
|  `WarmAppLaunchSatisfiedTransaction`  |  Conteggio  |  Il numero di avvii rapidi di app completati in meno di 2 secondi, che hanno fornito un'esperienza utente soddisfacente.  | 
|  `WarmAppLaunchToleratedTransaction`  |  Conteggio  |  Il numero di avvii rapidi di app completati tra 2 e 8 secondi, che hanno fornito un'esperienza utente tollerabile, ma non ideale.  | 
|  `WarmLaunchTime`  |  Millisecondi  |  Tempo impiegato per avviare l'applicazione dallo stato in background. Per Android: tempo intercorso tra l'applicazione e il `onCreate` completamento della creazione della prima attività. Per iOS: tempo compreso `UIApplicationWillEnterForegroundNotification` tra`didBecomeActiveNotification`.  | 

# Metriche personalizzate e metriche estese a cui puoi inviare CloudWatch
<a name="CloudWatch-RUM-custom-and-extended-metrics"></a>

Per impostazione predefinita, i monitor delle app RUM inviano le metriche a. CloudWatch Queste metriche e dimensioni predefinite sono elencate nelle [CloudWatch metriche che puoi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html) raccogliere con RUM. CloudWatch 

Inoltre, puoi impostare un monitor dell'app per esportare la metrica. Il monitor dell'app può inviare metriche estese, personalizzate o entrambe. Può inviarli a. CloudWatch
+ **Metriche personalizzate: le** metriche personalizzate sono metriche definite dall'utente. Con i parametri personalizzati, puoi utilizzare qualsiasi nome e spazio dei nomi del parametro. Per derivare i parametri, puoi utilizzare qualsiasi evento personalizzato, evento integrato, attributo personalizzato o attributo predefinito.

  Puoi inviare metriche personalizzate a. CloudWatch
+ **Metriche estese**: puoi inviare qualsiasi metrica CloudWatch RUM predefinita a CloudWatch con dimensioni aggiuntive. In questo modo, questi parametri possono offrirti una visione più dettagliata.

**Topics**
+ [parametri personalizzati](#CloudWatch-RUM-custom-metrics)
+ [Parametri estesi](#CloudWatch-RUM-vended-metrics)

## parametri personalizzati
<a name="CloudWatch-RUM-custom-metrics"></a>

Per inviare metriche personalizzate, devi utilizzare AWS APIs o AWS CLI anziché la console. Per ulteriori informazioni sull'utilizzo di AWS APIs, consulta [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html)e [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

Il numero massimo di definizioni di parametri personalizzati e parametri estesi che una singola destinazione può contenere è 2.000. Per ogni parametro personalizzato o esteso inviato a ciascuna destinazione, ogni combinazione di nome e valore della dimensione conta per tale limite. Non ti vengono addebitati costi per le metriche personalizzate derivate da qualsiasi tipo di evento o attributo di CloudWatch RUM.

L'esempio seguente mostra come creare un parametro personalizzato derivato da un evento personalizzato. Ecco l'esempio di evento personalizzato utilizzato:

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

Dato questo evento personalizzato, puoi creare un parametro personalizzato che conta il numero di visite all'URL di `amazonaws.com` dai browser Chrome. La seguente definizione crea un parametro denominato `AmazonVisitsCount` nel tuo account, nello spazio dei nomi `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\"]}}" 
        }
    ]
}
```

## Parametri estesi
<a name="CloudWatch-RUM-vended-metrics"></a>

Se configuri metriche estese, puoi inviare qualsiasi metrica CloudWatch RUM predefinita a CloudWatch con dimensioni aggiuntive in modo che le metriche offrano una visione più dettagliata.

Per ulteriori informazioni sulle metriche RUM predefinite, consulta. CloudWatch [CloudWatch metriche che puoi raccogliere con RUM CloudWatch](CloudWatch-RUM-metrics.md)

Il numero massimo di definizioni di parametri personalizzati e parametri estesi che una singola destinazione può contenere è 2.000. Per ogni parametro esteso o parametro personalizzato inviato a ciascuna destinazione, ogni combinazione di nome e valore della dimensione conta come parametro esteso per tale limite.

Quando invii metriche estese a CloudWatch, puoi utilizzare la console CloudWatch RUM per creare CloudWatch allarmi su di esse.

Non ti vengono addebitati costi per le metriche estese create per le metriche predefinite di RUM. CloudWatch 

### Metriche estese dell'applicazione Web
<a name="CloudWatch-RUM-web-extended-metrics"></a>

Le seguenti dimensioni sono supportate per le metriche estese delle applicazioni Web:
+ `BrowserName`

  Valori delle dimensioni di esempio: `Chrome`, `Firefox`, `Chrome Headless`
+ `CountryCode`: utilizza il formato ISO-3166 con codici a due lettere.

  Valori delle dimensioni di esempio: `US`, `JP`, `DE`
+ `DeviceType`

  Valori delle dimensioni di esempio: `desktop`, `mobile`, `tablet`, `embedded`
+ `FileType`

  Valori delle dimensioni di esempio: `Image`, `Stylesheet`
+ `OSName`

  Valori delle dimensioni di esempio: `Linux`, `Windows`, `iOS`, `Android`
+ `PageId`

### Metriche estese per applicazioni mobili
<a name="CloudWatch-RUM-mobile-extended-metrics"></a>

Le seguenti dimensioni sono supportate per le metriche estese delle applicazioni mobili:
+ `ScreenName`
  + Valore derivante dall'attributo screen name - `attributes.screen.name` dell'applicazione
  + Valori di esempio: HomeScreen, SettingsView, ProfilePage
+ `DeviceModel`
  + Valore derivante dall'attributo del modello del dispositivo - `resource.attributes.device.model.name`
  + Valori di esempio: iPhone14,3, SM-G998B
+ `OSVersion`
  + Valore derivante dall'attributo della versione del sistema operativo - `resource.attributes.os.version`
  + Valori di esempio: 16.0, 13.0

**Nota**  
Metriche predefinite attualmente supportate per le applicazioni mobili: `ScreenLoadTime``ScreenLoadCount`,`NetworkLatency`,,`Http4xxCount`,`Http5xxCount`,`CrashCount`,`ANRCount`,`AppHangCount`, `ColdLaunchTime``WarmLaunchTime`, `SessionCount` e. `SpanPayloadSize` `LogPayloadSize`

### Configurazione di parametri estesi mediante la console
<a name="CloudWatch-RUM-extended-metrics-console"></a>

Per utilizzare la console a cui inviare metriche estese CloudWatch, procedi nel seguente modo.

Per informazioni sull'utilizzo di per AWS APIs inviare metriche estese a entrambi CloudWatch, consulta [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html)e. [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html)

**Per utilizzare la console per configurare un'app, monitora e invia metriche estese RUM a CloudWatch**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli il nome del monitor dell'app a cui inviare le metriche.

1. Scegli la scheda **Configuration** (Configurazione) e infine **RUM extended metrics** (Metriche RUM estese).

1. Scegli **Send metrics** (Invia parametri).

1. Seleziona uno o più nomi di parametri da inviare con dimensioni aggiuntive.

1. Seleziona uno o più fattori da utilizzare come dimensioni per queste metriche. Man mano che effettui le tue scelte, il numero di metriche estese creati viene visualizzato in **Number of extended metrics** (Numero di parametri estesi).

   Questo numero viene calcolato moltiplicando il numero di nomi dei parametri scelti per il numero delle diverse dimensioni create.

   1. Per inviare una metrica con l'ID di pagina come dimensione, scegli **Cerca l'ID della pagina**, quindi seleziona la pagina IDs da utilizzare.

   1. Per inviare un parametro con il tipo di dispositivo come dimensione, scegli **Desktop devices** (Dispositivi desktop) o **Mobile and tablets** (Dispositivi mobili e tablet).

   1. Per inviare un parametro con il sistema operativo come dimensione, seleziona uno o più sistemi operativi in **Operating system** (Sistema operativo).

   1. Per inviare un parametro con il tipo di browser come dimensione, seleziona uno o più browser in **Browsers** (Browser).

   1. Per inviare un parametro con la geolocalizzazione come dimensione, seleziona una o più posizioni in **Locations** (Posizioni).

      Nell'elenco verranno visualizzate solo le posizioni da cui questo monitoraggio dell'app ha riportato le metriche.

1. Quando hai finito di selezionare le opzioni, scegli **Send metrics** (Invia metriche).

1. (Facoltativo) Nell'elenco **Extended metrics** (Metriche estese), crea un allarme che controlli uno dei parametri scegliendo **Create alarm** (Crea allarme) nella riga relativa al parametro.

   Per informazioni generali sugli CloudWatch allarmi, consulta. [Utilizzo degli CloudWatch allarmi Amazon](CloudWatch_Alarms.md) Per un tutorial sull'impostazione di un allarme in base a una metrica estesa CloudWatch RUM, vedi. [Tutorial: creazione di un parametro esteso e del relativo allarme](#CloudWatch-RUM-extended-metrics-alarmtutorial)

**Interruzione dell'invio di metriche estese**

**Per utilizzare la console al fine di interrompere l'invio di metriche estese**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli il nome del monitor dell'app a cui inviare le metriche.

1. Scegli la scheda **Configuration** (Configurazione) e infine **RUM extended metrics** (Metriche RUM estese).

1. Seleziona una o più combinazioni di nome e dimensione dei parametri per interrompere l'invio. Quindi scegli **Actions** (Operazioni), **Delete** (Elimina).

### Tutorial: creazione di un parametro esteso e del relativo allarme
<a name="CloudWatch-RUM-extended-metrics-alarmtutorial"></a>

Questo tutorial mostra come impostare una metrica estesa a cui inviare CloudWatch e quindi come impostare un allarme su quella metrica. In questo tutorial, crei una metrica che tiene traccia JavaScript degli errori nel browser Chrome.

**Per configurare il parametro esteso e impostare un allarme su di esso**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli il nome del monitor dell'app a cui inviare la metrica.

1. Scegli la scheda **Configuration** (Configurazione) e infine **RUM extended metrics** (Metriche RUM estese).

1. Scegli **Send metrics** (Invia parametri).

1. Seleziona **JSErrorCount**.

1. In **Browsers** (Browser), seleziona **Chrome**.

   Questa combinazione di **JSErrorCount** e **Chrome** invierà una metrica estesa a CloudWatch. La metrica conta JavaScript gli errori solo per le sessioni utente che utilizzano il browser Chrome. **Il nome della metrica sarà **JsErrorCount**e il nome della dimensione sarà Browser.**

1. Scegli **Send metrics** (Invia parametri).

1. Nell'elenco delle **metriche estese**, scegli **Crea allarme** nella riga visualizzata **JsErrorCount**sotto **Nome** e in cui viene visualizzato **Chrome**. **BrowserName**

1. In **Specificare metrica e condizioni**, conferma che il **nome e i **BrowserName**campi della metrica** siano precompilati con i valori corretti.

1. In **Statistic** (Statistica), seleziona la statistica che desideri utilizzare per l'allarme. Il valore **Average** (Media) è ideale per questo tipo di parametro di conteggio.

1. Per **Period (Periodo)**, selezionare **5 minutes (5 minuti)**.

1. In **Condizioni**, effettuare le seguenti operazioni:
   + Scegli **Static** (Statico).
   + Scegli **Greater** (Maggiore) per specificare che l'allarme deve passare allo stato ALARM quando il numero di errori è superiore alla soglia specificata.
   + In **than...** (di...), inserisci il numero per la soglia di allarme. L'allarme entra nello stato ALARM quando il numero di errori in un periodo di 5 minuti supera questo numero.

1. (Facoltativo) Per impostazione predefinita, l'allarme passa allo stato ALARM non appena il numero di errori supera la soglia impostata durante un periodo di 5 minuti. Facoltativamente, è possibile modificare questa impostazione in modo che l'allarme entri nello stato ALARM solo se questo numero viene superato per un periodo superiore a 5 minuti.

   Per eseguire questa operazione, scegli **Additional configuration** (Configurazione aggiuntiva), quindi in **Datapoints to alarm** (Data point per allarme) specifica quanti periodi di 5 minuti devono avere un numero di errori superiore alla soglia per attivare l'allarme. Ad esempio, puoi selezionare 2 su 2 per attivare l'allarme solo quando due periodi consecutivi di 5 minuti superano la soglia, oppure 2 su 3 attivarlo se due dei tre periodi consecutivi di 5 minuti superano la soglia. 

   Per ulteriori informazioni in merito a questo tipo di valutazione degli allarmi, consulta [Valutazione degli allarmi](alarm-evaluation.md).

1. Scegli **Next (Successivo)**.

1. In **Configure actions** (Configura operazioni), specifica cosa deve accadere quando l'allarme si attiva. Per ricevere una notifica con Amazon SNS, procedi come segue:
   + Scegliere **Add notification (Aggiungi notifica)**.
   + Scegli **In allarme**.
   + Seleziona un argomento SNS esistente o crearne uno nuovo. Se ne crei uno nuovo, specifica un nome e aggiungi almeno un indirizzo e-mail.

1. Scegli **Next (Successivo)**.

1. Inserisci un nome e, facoltativamente, una descrizione per l'allarme, quindi scegli **Next** (Successivo).

1. Verifica i dettagli e scegli **Create alarm** (Crea allarme).

# Protezione e riservatezza dei dati con RUM CloudWatch
<a name="CloudWatch-RUM-privacy"></a>

Il [modello di responsabilità AWS condivisa](https://aws.amazon.com/compliance/shared-responsibility-model/) si applica alla protezione e alla privacy dei dati in Amazon CloudWatch RUM. Come descritto in questo modello, AWS è responsabile della protezione dell'infrastruttura globale che gestisce tutto il AWS cloud. L’utente è responsabile del controllo dei contenuti ospitati su questa infrastruttura. Per ulteriori informazioni sulla privacy dei dati, consulta [Domande frequenti sulla privacy dei dati](https://aws.amazon.com/compliance/data-privacy-faq/). Per informazioni sulla protezione dei dati in Europa, consulta [il post sul blog The AWS Shared Responsibility Model e sul GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) sul AWS Security Blog. Per ulteriori risorse sulla conformità ai requisiti GDPR, consulta la sezione [Centro generale sulla protezione dei dati (GDPR)](https://aws.amazon.com/compliance/gdpr-center/).

Amazon CloudWatch RUM genera un frammento di codice da incorporare nel codice del sito Web o dell'applicazione Web, in base all'immissione dei dati dell'utente finale che desideri raccogliere. Il client web, scaricato e configurato dallo snippet di codice, utilizza cookie (o tecnologie simili) per aiutare a raccogliere i dati dell'utente finale. L'uso di cookie (o tecnologie simili) è soggetto alle norme sulla privacy dei dati in alcune giurisdizioni. Prima di utilizzare Amazon CloudWatch RUM, ti consigliamo vivamente di valutare i tuoi obblighi di conformità ai sensi della legge applicabile, inclusi eventuali requisiti legali applicabili per fornire avvisi sulla privacy legalmente adeguati e ottenere i consensi necessari per l'uso dei cookie e il trattamento (inclusa la raccolta) dei dati degli utenti finali. Per ulteriori informazioni su come il client web utilizza i cookie (o tecnologie simili) e quali dati dell'utente finale raccoglie, consulta [Informazioni raccolte dal client web CloudWatch RUM](CloudWatch-RUM-datacollected.md) e [CloudWatch Cookie del client web RUM (o tecnologie simili)](#CloudWatch-RUM-cookies).

Consigliamo vivamente di non inserire mai informazioni identificative sensibili, ad esempio i numeri di account dei clienti, indirizzi email o altre informazioni personali in campi a formato libero. Tutti i dati che inserisci in Amazon CloudWatch RUM o in altri servizi potrebbero essere inclusi nei log di diagnostica. 



## CloudWatch Cookie del client web RUM (o tecnologie simili)
<a name="CloudWatch-RUM-cookies"></a>

Per impostazione predefinita, il client web CloudWatch RUM raccoglie determinati dati sulle sessioni utente. È possibile scegliere di abilitare i cookie affinché il client web raccolga anche un ID utente e un ID di sessione che persistano durante il caricamento delle pagine. L'ID utente viene generato in modo casuale da RUM.

Se questi cookie sono abilitati, RUM è in grado di visualizzare i seguenti tipi di dati quando si visualizza il pannello di controllo RUM per questo monitor dell'app.
+ Dati aggregati basati sull'utente IDs, come il numero di utenti unici e il numero di utenti diversi che hanno riscontrato un errore. 
+ Dati aggregati basati sulla sessione IDs, ad esempio il numero di sessioni e il numero di sessioni in cui si è verificato un errore. 
+ Il *percorso dell'utente*, ovvero la sequenza di pagine che include ogni sessione utente campionata. 

**Importante**  
Se non abiliti questi cookie (o tecnologie simili), il client web registra comunque alcune informazioni sulle sessioni dell'utente finale, come il browsertype/version, operating system type/version, il tipo di dispositivo e così via. Questi sono raccolti per fornire informazioni aggregate specifiche della pagina, come i parametri vitali web, le visualizzazioni di pagina e le pagine che hanno riscontrato errori. Per ulteriori informazioni sui tipi di dati registrati, consulta [Informazioni raccolte dal client web CloudWatch RUM](CloudWatch-RUM-datacollected.md).

# Informazioni raccolte dal client web CloudWatch RUM
<a name="CloudWatch-RUM-datacollected"></a>

Questa sezione documenta lo **PutRumEvents**schema, che definisce la struttura dei dati che è possibile raccogliere dalle sessioni utente utilizzando CloudWatch RUM.

Una **PutRumEvents**richiesta invia a CloudWatch RUM una struttura di dati con i seguenti campi.
+ L'ID di questo batch di eventi RUM
+ Dettagli del monitor dell'app, che includono i seguenti:
  + ID dell'app del monitor
  + Versione dell'applicazione monitorata
+ Dettagli dell'utente, che comprendono i seguenti.** Questo viene raccolto solo se sul monitor dell'app sono abilitati i cookie.**
  + ID utente generato dal client web
  + ID sessione
+ La gamma di [Eventi RUM](#CloudWatch-RUM-datacollected-event) in questo batch.

## Schema eventi RUM
<a name="CloudWatch-RUM-datacollected-event"></a>

La struttura di ciascun evento RUM include i campi riportati di seguito.
+ L'ID dell'evento
+ Un Timestamp
+ Il tipo di evento
+ L'agente utente
+ [Metadati](#CloudWatch-RUM-datacollected-metadata)
+ [Dettagli evento RUM](#CloudWatch-RUM-datacollected-eventDetails)

## Metadati degli eventi RUM
<a name="CloudWatch-RUM-datacollected-metadata"></a>

I metadati includono metadati di pagina, metadati dell'agente utente, metadati di geolocalizzazione e metadati di dominio.

### Metadati della pagina
<a name="CloudWatch-RUM-datacollected-metadata-page"></a>

I metadati della pagina includono quanto segue:
+ ID pagina
+ Titolo pagina
+ ID pagina principale. - **Questo viene raccolto solo se sul monitor di app sono abilitati i cookie.**
+ Profondità di interazione - **Questo viene raccolto solo se sul monitor di app sono abilitati i cookie.**
+ Tag di pagina: puoi aggiungere tag agli eventi delle pagine per raggruppare le pagine. Per ulteriori informazioni, consulta [Utilizzo dei gruppi di pagine](CloudWatch-RUM-page-groups.md).

### Metadati dell'agente utente
<a name="CloudWatch-RUM-datacollected-metadata-useragent"></a>

I metadati dell'agente utente includono quanto segue:
+ Lingua browser
+ Nome browser
+ Versione browser
+ Nome del sistema operativo
+ Versione del sistema operativo
+ Tipo dispositivo
+ Tipo di piattaforma

### Metadati di geolocalizzazione
<a name="CloudWatch-RUM-datacollected-metadata-geolocation"></a>

I metadati di geolocalizzazione includono quanto segue:
+ Codice del paese
+ Codice di suddivisione

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

I metadati del dominio includono il dominio URL.

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

I dettagli di un evento seguono uno dei seguenti tipi di schemi, a seconda del tipo di evento.

### Evento di avvio della sessione
<a name="CloudWatch-RUM-datacollected-sessionstart"></a>

Questo evento non contiene campi. **Questo viene raccolto solo se sul monitor dell'app sono abilitati i cookie.**

### Schema di visualizzazione pagina
<a name="CloudWatch-RUM-datacollected-pageview"></a>

Un'evento di **Visualizzazione pagina** contiene le seguenti proprietà. È possibile disattivare la raccolta di viste pagina configurando il client Web. Per ulteriori informazioni, consulta la [documentazione del client web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nome | Tipo | Description | 
| --- | --- | --- | 
|  **ID pagina** |  Stringa  |  ID che rappresenta in modo univoco questa pagina all'interno dell'applicazione. Per impostazione predefinita, questo è il percorso URL.  | 
|  **ID pagina principale** |  Stringa  |  L'ID della pagina in cui si trovava l'utente quando si è spostato alla pagina corrente. **Questo viene raccolto solo se sul monitor dell'app sono abilitati i cookie.**   | 
|  **Profondità di interazione** |  Stringa  |  **Questo viene raccolto solo se sul monitor dell'app sono abilitati i cookie.**   | 

### JavaScript schema di errore
<a name="CloudWatch-RUM-datacollected-JavaScriptError"></a>

JavaScript gli eventi di errore generati dall'agente contengono le seguenti proprietà. Il client web raccoglie questi eventi solo se si è scelto di raccogliere gli errori di telemetria.


| Nome | Tipo | Description | 
| --- | --- | --- | 
|  **Tipi di errore** |  Stringa  |  Nome dell'errore, se esiste. Per ulteriori informazioni, consulta [Error.prototype.name](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name). Alcuni browser potrebbero non supportare i tipi di errore.  | 
|  **Messaggio di errore** |  Stringa  |  Messaggio di errore. Per ulteriori informazioni, consulta [Error.prototype.message](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message). Se il campo di errore non esiste, questo è il messaggio dell'evento di errore. Per ulteriori informazioni, consulta [ErrorEvent](https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent).  I messaggi di errore potrebbero non essere coerenti su diversi browser.  | 
|  **Traccia della pila** |  Stringa  |  La traccia della pila dell'errore, se esistente, è troncata a 150 caratteri. Per ulteriori informazioni, consulta [Error.prototype.stack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack).  Alcuni browser potrebbero non supportare le tracce della pila.  | 

### Schema eventi DOM
<a name="CloudWatch-RUM-datacollected-DOMEvent"></a>

Gli eventi DOM (Document Object Model) generati dall'agente contengono le seguenti proprietà. Questi eventi non vengono raccolti per impostazione predefinita. Vengono raccolti solo se si attiva la telemetria delle interazioni. Per ulteriori informazioni, consultate la [documentazione del client web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Nome | Tipo | Description | 
| --- | --- | --- | 
|  **Evento** |  Stringa  |  Il tipo di evento DOM, come click, scorrimento o passaggio del mouse. Per ulteriori informazioni, consulta [Riferimento evento](https://developer.mozilla.org/en-US/docs/Web/Events).  | 
|  **Elemento** |  Stringa  |  Il tipo di elemento DOM  | 
|  **Elemento ID** |  Stringa  |  Se l'elemento che ha generato l'evento ha un ID, questa proprietà memorizza tale ID. Per ulteriori informazioni, consulta [Element.id](https://developer.mozilla.org/en-US/docs/Web/API/Element/id).  | 
|  **CSSLocator** |  Stringa  |  Il localizzatore CSS utilizzato per identificare l'elemento DOM.  | 
|  **InteractionId** |  Stringa  |  Un ID univoco per l'interazione tra l'utente e l'interfaccia utente.  | 

### Schema eventi di navigazione
<a name="CloudWatch-RUM-datacollected-NavigationEvent"></a>

Gli eventi di navigazione vengono raccolti solo se il monitor dell'app ha attivato la telemetria delle prestazioni.

Gli eventi di navigazione utilizzano [la temporizzazione di navigazione di livello 1](https://www.w3.org/TR/navigation-timing/#performancetiming) e [la temporizzazione di navigazione di livello](https://w3c.github.io/navigation-timing) 2. APIs Il livello 2 APIs non è supportato su tutti i browser, quindi questi campi più recenti sono facoltativi.

**Nota**  
Le metriche del timestamp si basano su. [DOMHighResTimestamp](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp) Con Level 2 APIs, per impostazione predefinita tutti gli orari sono relativi a. `startTime` Ma per il livello 1, il parametro `navigationStart` viene sottratto dai parametri del timestamp per ottenere valori relativi. Tutti i valori del timestamp sono espressi in millisecondi.

Gli eventi di navigazione contengono le seguenti proprietà.


| Nome | Tipo | Description | Note | 
| --- | --- | --- | --- | 
|  **Tipo di iniziatore** |  Stringa  |  Rappresenta il tipo di risorsa che ha avviato l'evento delle prestazioni.  |  **Value (Valore):** «navigazione» **Livello 1:** «navigazione» **Livello 2:** entryData.initiatorType | 
|  **Tipo di navigazione** |  Stringa  |  Rappresenta il tipo di navigazione. Questo attributo non è obbligatorio. |  **Valore** Il valore deve essere uno dei seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html) | 
|  **startTime** |  Numero  |  Indica quando viene attivato l'evento.  |  **Value (Valore):** 0 **Livello 1:**entrydata.navigationStart - entryData.NavigationStart  **Livello 2:** entryData.startTime | 
|  **unloadEventStart** |  Numero  |  Indica l'ora in cui il documento precedente nella finestra ha iniziato a scaricarsi dopo che l'evento `unload` è stato lanciato.  |  **Value (Valore):** Se non esiste un documento precedente o se il documento precedente o uno dei reindirizzamenti necessari non hanno la stessa origine, il valore restituito è 0. **Livello 1:** <pre>entryData.unloadEventStart > 0<br />  ? entryData.unloadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Livello 2: EntryData**. unloadEventStart | 
|  **promptForUnload** |  Numero  |  Il tempo necessario per scaricare il documento. In altre parole, il tempo tra `unloadEventStart` e `unloadEventEnd`. `UnloadEventEnd` rappresenta il momento in millisecondi al termine del gestore eventi di scarico.  |  **Value (Valore):** Se non esiste un documento precedente o se il documento precedente o uno dei reindirizzamenti necessari non hanno la stessa origine, il valore restituito è 0. **Livello 1:** EntryData. unloadEventEnd - Dati di ingresso. unloadEventStart **Livello 2:** EntryData. unloadEventEnd - Dati di ingresso. unloadEventStart | 
|  **Redirect Count** |  Numero  |  Un numero che rappresenta il numero di reindirizzamenti dall'ultima navigazione non reindirizzata nel contesto di navigazione corrente.  Questo attributo non è obbligatorio. |  **Value (Valore):** Se non è presente alcun reindirizzamento o se è presente un reindirizzamento non della stessa origine del documento di destinazione, il valore restituito è 0. **Livello 1:** Non disponibile **Livello 2:** entryData.redirectCount | 
|  **RedirectStart** |  Numero  |  L'ora in cui inizia il primo reindirizzamento HTTP.   |  **Value (Valore):** Se non è presente alcun reindirizzamento o se è presente un reindirizzamento non della stessa origine del documento di destinazione, il valore restituito è 0. **Livello 1:** <pre>entryData.redirectStart > 0<br />  ? entryData.redirectStart - entryData.navigationStart<br />  : 0</pre> **Livello 2:** entryData.redirectStart | 
|  **Tempo di reindirizzamento** |  Numero  |  Il tempo impiegato per il reindirizzamento HTTP. Questa è la differenza tra `redirectStart` e `redirectEnd`.   |  **Livello 1:**: entryData.redirectEnd - entryData.redirectStart **Livello 2:**: entryData.redirectEnd - entryData.redirectStart | 
|  **workerStart** |  Numero  |  Questa è una proprietà dell'interfaccia `PerformanceResourceTiming`. Segna l'inizio dell'operazione del thread di lavoro. Questo attributo non è obbligatorio. |  **Value (Valore):** Se un thread Service Worker è già in esecuzione o immediatamente prima di avviare il thread Service Worker, questa proprietà restituisce l'ora immediatamente prima dell'invio di `FetchEvent`. Restituisce 0 se la risorsa non viene intercettata da un Service Worker. **Livello 1:** Non disponibile **Livello 2:** entryData.workerStart | 
|  **workerTime** |  Numero  |  Se la risorsa viene intercettata da un Service Worker, restituisce il tempo necessario per l'operazione del thread di lavoro. Questo attributo non è obbligatorio. |  **Livello 1:** Non disponibile  **Livello 2:** <pre>entryData.workerStart > 0<br />   ? entryData.fetchStart - entryData.workerStart<br />   : 0</pre>  | 
|  **fetchStart** |  Numero  |  Il momento in cui il browser è pronto a recuperare il documento utilizzando una richiesta HTTP. Questo è prima di controllare qualsiasi cache dell'applicazione. |  **Livello 1:**  <pre>: entryData.fetchStart > 0<br />  ? entryData.fetchStart - entryData.navigationStart<br />  : 0</pre> **Livello 2:** entrydata.fetchStart | 
|  **domainLookupStart** |  Numero  |  Ora di avvio della ricerca del dominio. |  **Value (Valore):** Se viene utilizzata una connessione persistente o se le informazioni sono memorizzate in una cache o in una risorsa locale, il valore sarà lo stesso `fetchStart`. **Livello 1:** <pre>entryData.domainLookupStart > 0<br />  ? entryData.domainLookupStart - entryData.navigationStart<br />  : 0</pre> **Livello 2:** EntryData. domainLookupStart | 
|  **dns** |  Numero  |  Il tempo necessario per la ricerca del dominio. |  **Value (Valore):** Se le risorse e i record DNS sono memorizzati nella cache, il valore previsto è 0. **Livello 1:** EntryData. domainLookupEnd - Dati di ingresso. domainLookupStart **Livello 2:** EntryData. domainLookupEnd - Dati di ingresso. domainLookupStart | 
|  **nextHopProtocol** |  Stringa  |  Stringa che rappresenta il protocollo di rete utilizzato per recuperare la risorsa. Questo attributo non è obbligatorio. |  **Livello 1:** Non disponibile **Livello 2:** EntryData. nextHopProtocol | 
|  **connectStart** |  Numero  |  Il tempo immediatamente prima che l'agente utente inizi a stabilire la connessione al server per recuperare il documento. |  **Valore:** se viene utilizzata una connessione RFC2616 persistente o se il documento corrente viene recuperato dalle cache dell'applicazione o dalle risorse locali pertinenti, questo attributo restituisce il valore di. `domainLookupEnd` **Livello 1:** <pre>entryData.connectStart > 0<br />  ? entryData.connectStart - entryData.navigationStart<br />  : 0</pre> **Livello 2:** entryData.connectStart  | 
|  **connect** |  Numero  |  Misura il tempo necessario per stabilire le connessioni di trasporto o per eseguire l'autenticazione SSL. Include anche il tempo bloccato impiegato quando sono presenti troppe richieste simultanee emesse dal browser.  |  **Livello 1:** entryData.connectEnd - EntryData.connectStart **Livello 2:** entryData.connectEnd - EntryData.connectStart | 
|  **secureConnectionStart** |  Numero  |  Se lo schema URL della pagina corrente è «https», questo attributo restituisce il tempo immediatamente prima che l'agente del'utente avvii il processo di handshake per proteggere la connessione corrente. Restituisce 0 se non viene utilizzato HTTPS. Per ulteriori informazioni sugli schemi URL, consulta [Rappresentazione dell'URL](https://url.spec.whatwg.org/#concept-url-scheme).  |  **Formula: EntryData**. secureConnectionStart | 
|  **Tempo tls** |  Numero  |  Il tempo necessario per completare una handshake SSL.  |  **Livello 1:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre> **Livello 2:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre>  | 
|  **Inizio richiesta** |  Numero  |  Il tempo immediatamente prima che l'agente utente inizi a richiedere la risorsa dal server, dalle cache delle applicazioni pertinenti o dalle risorse locali.   | **Livello 1:** <pre>: entryData.requestStart > 0<br />  ? entryData.requestStart - entryData.navigationStart<br />  : 0<br /></pre> **Livello 2:** entryData.requestStart | 
|  **timeToFirstByte** |  Numero  |  Il tempo necessario per ricevere il primo byte di informazioni dopo la richiesta. Questa tempo è relativo al `startTime`.   | **Livello 1:** entryData.responseStart - entryData.requestStart **Livello 2:** entryData.responseStart - entryData.requestStart | 
|  **Avvio risposta** |  Numero  |  Il tempo immediatamente dopo che il parser HTTP dell'agente utente riceve il primo byte della risposta dalle cache dell'applicazione pertinenti, dalle risorse locali o dal server.   | **Livello 1:** <pre>entryData.responseStart > 0<br />   ? entryData.responseStart - entryData.navigationStart<br />   : 0</pre> **Livello 2:** entryData.responseStart   | 
|  **responseTime** |  Stringa  |  Il tempo necessario per ricevere una risposta completa sotto forma di byte dalle cache delle applicazioni pertinenti, dalle risorse locali o dal server.   | **Livello 1:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre> **Livello 2:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre>  | 
|  **domInteractive** |  Numero  |  Il momento in cui il parser ha terminato il suo lavoro sul documento principale e viene costruito il DOM HTML. In questo momento, il `Document.readyState` cambia in «interattivo» e l'evento `readystatechange` corrispondente viene generato.  | **Livello 1:** <pre>entryData.domInteractive > 0<br />  ? entryData.domInteractive - entryData.navigationStart<br />  : 0</pre> **Livello 2:**Entrydata.com Interactive  | 
|  **domContentLoadedEventStart** |  Numero  |  Rappresenta il valore temporale uguale al tempo immediatamente precedente all'attivazione dell'evento DOMContent Loaded da parte dello user agent nel documento corrente. L'evento DOMContent Loaded si attiva quando il documento HTML iniziale è stato completamente caricato e analizzato. A questo punto, il documento HTML principale ha terminato l'analisi, il browser inizia a costruire l'albero di rendering e le sottofonti devono ancora essere caricate. Questo non attende che i fogli di stile, le immagini e i fotogrammi secondari finiscano il caricamento.  | **Livello 1:** <pre>entryData.domContentLoadedEventStart > 0<br />  ? entryData.domContentLoadedEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Livello 2: EntryData**. domContentLoadedEventStart  | 
|  **domContentLoaded** |  Numero  |  Questa ora di inizio e di fine della costruzione dell'albero di rendering è contrassegnata dalla `domContentLoadedEventStart` e `domContentLoadedEventEnd`. Consente a CloudWatch RUM di tracciare l'esecuzione. Questa proprietà è la differenza tra `domContentLoadedStart` e `domContentLoadedEnd`. Durante questo periodo, DOM e CSSOM sono pronti. Questa proprietà attende l'esecuzione dello script, ad eccezione degli script asincroni e creati dinamicamente. Se gli script dipendono dai fogli di stile, `domContentLoaded` aspetta anche sui fogli di stile. Non aspetta le immagini.   I valori effettivi di `domContentLoadedStart` e `domContentLoadedEnd` approssimati a `domContentLoaded` nel pannello di rete di Google Chrome. Indica il tempo di costruzione dell'albero di rendering HTML DOM \$1 CSSOM dall'inizio del processo di caricamento della pagina. Nel caso dei parametri di navigazione, il valore di `domContentLoaded` rappresenta la differenza tra i valori iniziale e finale, ovvero il tempo necessario per scaricare le sottofonti e la costruzione dell'albero di rendering.    | **Livello 2:** EntryData. domContentLoadedEventEnd - Dati di ingresso. domContentLoadedEventStart  **Livello 2:** EntryData. domContentLoadedEventEnd - Dati di ingresso. domContentLoadedEventStart  | 
|  **DOM completo** |  Numero  |  Il tempo immediatamente prima che il browser imposti la disponibilità corrente del documento corrente per il completamento. A questo punto, il caricamento di sottofonti, come le immagini, è completo. Ciò include il tempo impiegato per scaricare contenuti bloccanti come CSS e sincroni. JavaScript Questo si avvicina a `loadTime` nel pannello di Rete di Google Chrome.   | **Livello 1:** <pre>entryData.domComplete > 0<br />  ? entryData.domComplete - entryData.navigationStart<br />  : 0<br /></pre> **Livello 2:** Entrydata.com completo  | 
|  **domProcessingTime** |  Numero  |  Il tempo totale tra la risposta e l'avvio dell'evento di caricamento.  | **Livello 1: EntryData**. loadEventStart - EntryData.responseEnd **Livello 2: EntryData.** loadEventStart - EntryData.responseEnd  | 
|  **loadEventStart** |  Numero  |  Il tempo immediatamente prima dell'evento `load` del documento corrente viene attivato.  |  **Livello 1:** <pre>entryData.loadEventStart > 0<br />  ? entryData.loadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Livello 2: EntryData.** loadEventStart | 
|  **loadEventTime** |  Numero  |  La differenza tra `loadEventStart` e `loadEventEnd`. Durante questo periodo verranno attivate funzioni o logiche aggiuntive in attesa di questo evento di caricamento. |  **Livello 1:** EntryData. loadEventEnd - Dati di ingresso. loadEventStart **Livello 2:** EntryData. loadEventEnd - Dati di ingresso. loadEventStart | 
|  **durata** |  Stringa  |  La durata è il tempo di caricamento totale della pagina. Registra i tempi per il download della pagina principale e di tutte le sue sottofonti sincrone e anche per il rendering della pagina. Le risorse asincrone come gli script continuano a essere scaricate in un secondo momento. Questa è la differenza tra le proprietà `loadEventEnd` e `startTime`.  | **Livello 1:** EntryData. loadEventEnd - EntryData.navigationStart **Livello 2:** entryData.duration | 
|  **Dimensioni intestazione** |  Numero  |  Restituisce la differenza tra `transferSize` e `encodedBodySize`. Questo attributo non è obbligatorio.  | **Livello 1:** Non disponibile **Livello 2**: entryData.transferSize - EntryData. encodedBodySize **Livello 2:** entryData.transferSize - EntryData. encodedBodySize | 
|  **Rapporto di compressione** |  Numero  |  Il rapporto di `encodedBodySize` e `decodedBodySize`. Il valore di `encodedBodySize` è la dimensione compressa della risorsa escludendo le intestazioni HTTP. Il valore di `decodedBodySize` è la dimensione decompressa della risorsa escludendo le intestazioni HTTP. Questo attributo non è obbligatorio.  | **Livello 1:** Non disponibile. **Livello 2:**<pre>entryData.encodedBodySize > 0<br />  ? entryData.decodedBodySize / entryData.encodedBodySize<br />  : 0</pre>  | 
|  **navigationTimingLevel** |  Numero  |  La versione dell'API di tempistica di navigazione.  | **Value (Valore):** 1 o 2  | 

### Schemi di eventi delle risorse
<a name="CloudWatch-RUM-datacollected-ResourceEvent"></a>

Gli eventi delle risorse vengono raccolti solo se il monitor dell'app ha attivato la telemetria delle prestazioni.

[Le metriche del timestamp si basano su The typedef. DOMHigh ResTimeStamp ](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp) Con Level 2 APIs, per impostazione predefinita tutti gli orari sono relativi a. `startTime` Tuttavia, per il livello 1 APIs, la `navigationStart` metrica viene sottratta dalle metriche del timestamp per ottenere valori relativi. Tutti i valori del timestamp sono espressi in millisecondi.

Gli eventi delle risorse generati dall'agente contengono le seguenti proprietà.


| Nome | Tipo | Description | Note | 
| --- | --- | --- | --- | 
|  **targetUrl** |  Stringa  |  Restituisce l'URL della risorsa.  |  **Formula:** [EntryData.name](http://entrydata.name/) | 
|  **Tipo di iniziatore** |  Stringa  |  Rappresenta il tipo di risorsa che ha avviato l'evento della risorsa per le prestazioni.  |  **Value (Valore):** «risorsa» **Formula:** entryData.initiatorType | 
|  **durata** |  Stringa  |  Restituisce la differenza tra proprietà `responseEnd` e `startTime`.Questo attributo non è obbligatorio.  | **Formula:** entryData.duration | 
|  **Dimensioni di trasferimento** |  Numero  |  Restituisce la dimensione (in ottetti) della risorsa recuperata, inclusi i campi di intestazione della risposta e il corpo del payload della risposta.Questo attributo non è obbligatorio.  | **Formula:** entryData.transferSize | 
|  **TipoFile** |  Stringa  |  Estensioni derivate dal pattern URL di destinazione.  |   | 

### Il più grande schema di eventi di pittura contentful
<a name="CloudWatch-RUM-datacollected-LargestPaintEvent"></a>

I più grandi eventi di pittura contentful contengono le seguenti proprietà.

Questi eventi vengono raccolti solo se il monitor dell'app ha attivato la telemetria delle prestazioni.


| Nome | Description | 
| --- | --- | 
|  **Valore** |  Per ulteriori informazioni, consulta [Web Vitals](https://web.dev/vitals/) (Informazioni sulla salute Web).  | 

### Primo evento di ritardo di input
<a name="CloudWatch-RUM-datacollected-FirstInputDelayEvent"></a>

I primi eventi di ritardo di input contengono le seguenti proprietà.

Questi eventi vengono raccolti solo se il monitor dell'app ha attivato la telemetria delle prestazioni.


| Nome | Description | 
| --- | --- | 
|  **Valore** |  Per ulteriori informazioni, consulta [Web Vitals](https://web.dev/vitals/) (Informazioni sulla salute Web).  | 

### Evento di spostamento cumulativo del layout
<a name="CloudWatch-RUM-datacollected-CumulativeShift"></a>

Gli eventi cumulativi di spostamento di layout contengono le seguenti proprietà.

Questi eventi vengono raccolti solo se il monitor dell'app ha attivato la telemetria delle prestazioni.


| Nome | Description | 
| --- | --- | 
|  **Valore** |  Per ulteriori informazioni, consulta [Web Vitals](https://web.dev/vitals/) (Informazioni sulla salute Web).  | 

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

Gli eventi HTTP possono contenere le seguenti proprietà. Conterrà un campo `Response` o campo `Error`, ma non entrambi.

Questi eventi vengono raccolti solo se il monitor dell'app ha attivato la telemetria HTTP.


| Nome | Description | 
| --- | --- | 
|  **Richiesta** |  Il campo della richiesta include quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Risposta** |  La risposta include quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Errore** |  La sezione di errore include quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 

### Schemi di eventi X-Ray
<a name="CloudWatch-RUM-datacollected-xraytraceEvent"></a>

Questi eventi vengono raccolti solo se il monitor dell'app ha attivato il tracciamento X-Ray.

Per informazioni sugli schemi degli eventi X-Ray trace, consulta [documenti di un segmento AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-api-segmentdocuments.html).

# Tempi di cambio percorso per applicazioni a pagina singola
<a name="CloudWatch-RUM-route-change-timing"></a>

In un'applicazione tradizionale a più pagine, quando un utente richiede il caricamento di nuovi contenuti, l'utente sta effettivamente richiedendo una nuova pagina HTML dal server. Di conseguenza, il client web CloudWatch RUM acquisisce i tempi di caricamento utilizzando le normali metriche API prestazionali.

Tuttavia, le applicazioni Web a pagina singola utilizzano JavaScript Ajax per aggiornare l'interfaccia senza caricare una nuova pagina dal server. Gli aggiornamenti a pagina singola non vengono registrati dall'API di sincronizzazione del browser, ma utilizzano invece i tempi di modifica del percorso.

CloudWatch RUM supporta il monitoraggio sia del caricamento di pagine complete dal server sia degli aggiornamenti a pagina singola, con le seguenti differenze:
+ Per la tempistica del cambio del percorso, non ci sono parametri forniti dal browser come `tlsTime`, `timeToFirstByte` e così via.
+ Per la tempistica del cambio del percorso, il campo `initiatorType` sarà `route_change`. 

Il client web CloudWatch RUM ascolta le interazioni dell'utente che possono portare a una modifica del percorso e, quando tale interazione utente viene registrata, il client Web registra un timestamp. Quindi la tempistica del cambio del percorso inizierà se entrambe le condizioni seguenti sono vere:
+ Un'API della cronologia del browser (eccetto i pulsanti avanti e indietro del browser) è stata utilizzata per eseguire il cambio di percorso.
+ La differenza tra il tempo di rilevamento del cambio del percorso e il timestamp dell'ultima interazione dell'utente è inferiore a 1000 ms. In questo modo si evita l'asimmetria dei dati.

Quindi, una volta che inizia la sincronizzazione del cambio del percorso, tale tempistica viene completata se non ci sono richieste AJAX e mutazioni DOM in corso. Quindi il timestamp dell'ultima attività completata verrà utilizzato come timestamp di completamento.

La tempistica per il cambio de percorso scade se ci sono richieste AJAX o mutazioni DOM in corso per più di 10 secondi (per impostazione predefinita). In questo caso, il client web CloudWatch RUM non registrerà più la tempistica di questa modifica del percorso.

Di conseguenza, la durata di un evento di cambio del percorso viene calcolata come segue:

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

# Gestisci le tue applicazioni che utilizzano RUM CloudWatch
<a name="CloudWatch-RUM-manage"></a>

Segui i passaggi descritti in queste sezioni per gestire l'uso di RUM da parte delle tue applicazioni. CloudWatch

**Topics**
+ [Come faccio a trovare uno snippet di codice che ho già generato?](CloudWatch-RUM-find-code-snippet.md)
+ [Modifica delle impostazioni del monitor dell'app RUM CloudWatch](CloudWatch-RUM-edit-application.md)
+ [Interruzione dell'utilizzo di CloudWatch RUM o eliminazione del monitor di un'app](CloudWatch-RUM-delete-appmonitor.md)

# Come faccio a trovare uno snippet di codice che ho già generato?
<a name="CloudWatch-RUM-find-code-snippet"></a>

Per trovare un frammento di codice CloudWatch RUM che hai già generato per un'applicazione, segui questi passaggi.

**Per trovare uno snippet di codice già generato**

1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Vai alla scheda **Configurazione**, sezione **Frammenti di codice**.

1. Scegli **Copia/Scarica** per la tua rispettiva strumentazione.

# Modifica delle impostazioni del monitor dell'app RUM CloudWatch
<a name="CloudWatch-RUM-edit-application"></a>

Per modificare le impostazioni di un monitor app, seguire i seguenti passaggi. È possibile modificare qualsiasi impostazione tranne il nome del monitor dell'app.

**Per modificare il modo in cui l'applicazione utilizza CloudWatch RUM**

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli il pulsante accanto al nome dell'applicazione, quindi scegli **Operazioni**,**Modificare**.

1. Modificare tutte le impostazioni tranne il nome dell'applicazione. Per ulteriori informazioni in merito all'impostazione , consulta [Creazione di un monitor di app CloudWatch RUM per un'applicazione web](CloudWatch-RUM-get-started-create-app-monitor.md).

1. Al termine, scegli **Save** (Salva).

   La modifica delle impostazioni cambia lo snippet di codice. Ora è necessario incollare lo snippet di codice aggiornato nella propria applicazione.

1. **Dopo aver creato il frammento di codice, scegli **Copia negli appunti** o **Scarica**, quindi scegli Fine.**

   Per avviare il monitoraggio con le nuove impostazioni, inserire lo snippet di codice nell'applicazione.

# Interruzione dell'utilizzo di CloudWatch RUM o eliminazione del monitor di un'app
<a name="CloudWatch-RUM-delete-appmonitor"></a>

Per smettere di usare CloudWatch RUM con un'applicazione, rimuovi il frammento di codice generato da RUM dal codice dell'applicazione.

Per eliminare un monitor dell'app RUM, seguire i seguenti passaggi.

**Per eliminare un monitor dell'app**

1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli il pulsante accanto al nome dell'applicazione, quindi scegli **Operazioni**, **Elimina**.

1. Nel campo di conferma immetti **Delete** e quindi scegli **Delete** (Elimina).

1. Se non l'hai già fatto, elimina lo snippet di codice CloudWatch RUM dal codice dell'applicazione.

# Risoluzione dei problemi RUM CloudWatch
<a name="CloudWatch-RUM-troubleshooting"></a>

Questa sezione contiene suggerimenti per aiutarti a risolvere CloudWatch i problemi RUM.

## Non ci sono dati per la mia applicazione
<a name="CloudWatch-RUM-troubleshooting-nodata"></a>

In primo luogo, accertarsi che lo snippet di codice sia stato inserito correttamente nell'applicazione. Per ulteriori informazioni, consulta [Inserimento dello snippet di codice del monitor CloudWatch dell'app nell'applicazione](CloudWatch-RUM-get-started-insert-code-snippet.md).

Se questo non è il problema, forse non c'è ancora stato traffico verso la propria applicazione. Generare traffico accedendo all'applicazione nello stesso modo in cui farebbe un utente.

## I dati hanno smesso di essere registrati per la mia applicazione
<a name="CloudWatch-RUM-troubleshooting-nonewdata"></a>

L'applicazione potrebbe essere stata aggiornata e ora non contiene più un frammento di codice CloudWatch RUM. Controllare il codice dell'applicazione.

Un'altra possibilità è che qualcuno abbia aggiornato lo snippet di codice ma non abbia inserito lo snippet aggiornato nell'applicazione. Trovare lo snippet di codice corretto corrente seguendo le istruzioni in [Come faccio a trovare uno snippet di codice che ho già generato?](CloudWatch-RUM-find-code-snippet.md) e confrontarlo con lo snippet di codice incollato nella propria applicazione.