Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

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

Mit CloudWatch RUM können Sie eine echte Benutzerüberwachung durchführen, um clientseitige Daten über die Leistung Ihrer Web- und mobilen Anwendungen aus tatsächlichen Benutzersitzungen nahezu in Echtzeit zu sammeln und anzuzeigen. Für Webanwendungen können Sie Seitenladezeiten, clientseitige Fehler und das Benutzerverhalten analysieren. Für mobile Anwendungen können Sie Bildschirmladezeiten, App-Startzeiten, Netzwerkfehler, Abstürze und plattformspezifische Probleme wie Android Application Not Responding (ANR) und iOS App Hangs überwachen. Wenn Sie sich diese Daten ansehen, können Sie sie alle zusammenfassen und auch Aufschlüsselungen nach Gerätetypen, Betriebssystemen und anderen Merkmalen Ihrer Anwendungsnutzung einsehen.

Sie können die gesammelten Daten verwenden, um Leistungsprobleme auf der Clientseite schnell zu identifizieren und zu debuggen. CloudWatch RUM hilft Ihnen dabei, Anomalien in der Leistung Ihrer Anwendung zu visualisieren und relevante Debugging-Daten wie Fehlermeldungen, Stack-Traces und Benutzersitzungen zu finden. Sie können RUM auch verwenden, um die Bandbreite der Auswirkungen auf den Endbenutzer zu ermitteln, einschließlich der Anzahl der Benutzer, der geografischen Standorte und der Nutzung. browsers/devices 

Endbenutzerdaten, die Sie für CloudWatch RUM sammeln, werden 30 Tage lang aufbewahrt und dann automatisch gelöscht. Wenn Sie die RUM-Telemetriedaten für einen längeren Zeitraum behalten möchten, können Sie festlegen, dass der App-Monitor Kopien der Telemetriedaten an CloudWatch Logs in Ihrem Konto sendet. Anschließend können Sie den Aufbewahrungszeitraum für diese Protokollgruppe anpassen.

Um RUM zu verwenden, erstellen Sie eine *App-Überwachung* und geben einige Informationen an. RUM generiert einen Codeausschnitt, mit dem Sie Ihrer Anwendung eine Abhängigkeitsinjektion hinzufügen können. Das Snippet ruft den RUM-Client-Code nach Bedarf ab. Der RUM-Client erfasst Daten aus einem bestimmten Prozentsatz der Benutzersitzungen Ihrer Anwendung, die in einem vorgefertigten Dashboard angezeigt werden. Sie können angeben, aus welchem Prozentsatz der Benutzersitzungen Daten gesammelt werden sollen.

 CloudWatch RUM ist in [Application Signals](CloudWatch-Application-Monitoring-Sections.md) integriert, das Ihre Anwendungsdienste, Clients, Synthetics-Kanarien und Serviceabhängigkeiten erkennen und überwachen kann. Verwenden Sie Application Signals, um eine Liste oder eine visuelle Übersicht Ihrer Services zu erhalten, Integritätskennzahlen auf der Grundlage Ihrer Service-Level-Ziele (SLOs) einzusehen und eine Aufschlüsselung durchzuführen, um korrelierte Röntgenspuren für eine detailliertere Fehlerbehebung zu sehen. Um RUM-Client-Seitenanfragen in Application Signals zu sehen, aktivieren Sie X-Ray Active Tracing, wenn Sie [einen App-Monitor erstellen](CloudWatch-RUM-get-started-create-app-monitor.md). Für Webanwendungen können Sie dies auch aktivieren, indem Sie [den RUM-Webclient manuell konfigurieren](CloudWatch-RUM-configure-client.md). Ihre RUM-Clients werden auf der [Anwendungskarte](ServiceMap.md) angezeigt, die mit Ihren Services verbunden ist, und auf der [Service-Detailseite](ServiceDetail.md) der Services, die sie aufrufen. 

Die RUM-Clients sind Open Source. Weitere Informationen finden Sie unter [CloudWatch RUM-Webclient](https://github.com/aws-observability/aws-rum-web), dem [AWS Distro for OpenTelemetry (ADOT) Android SDK](https://github.com/aws-observability/aws-otel-android) und [AWS Distro for OpenTelemetry (ADOT](https://github.com/aws-observability/aws-otel-swift)) iOS SDK.

**RUM-Preise**

Informationen zur Preisgestaltung finden Sie unter [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/). 

**Verfügbarkeit in Regionen**

CloudWatch RUM ist derzeit in den folgenden Regionen erhältlich:
+ USA Ost (Nord-Virginia)
+ USA Ost (Ohio)
+ USA West (Nordkalifornien)
+ USA West (Oregon)
+ Afrika (Kapstadt)
+ AWS GovCloud (US-Ost)
+ AWS GovCloud (US-West)
+ Asien-Pazifik (Mumbai)
+ Asien-Pazifik (Hyderabad)
+ Asien-Pazifik (Melbourne)
+ Asien-Pazifik (Osaka)
+ Asien-Pazifik (Seoul)
+ Asien-Pazifik (Singapur)
+ Asien-Pazifik (Sydney)
+ Asien-Pazifik (Jakarta)
+ Asien-Pazifik (Malaysia)
+ Asien-Pazifik (Thailand)
+ Asien-Pazifik (Tokio)
+ Asien-Pazifik (Hongkong)
+ Kanada (Zentral)
+ Europe (Frankfurt)
+ Europa (Irland)
+ Europa (London)
+ Europa (Milan)
+ Europa (Paris)
+ Europa (Spain)
+ Europa (Stockholm)
+ Europa (Zürich)
+ AWS Europäische Sovereign Cloud (Deutschland)
+ Middle East (Bahrain)
+ Naher Osten (VAE)
+ Mexiko (Zentral)
+ Südamerika (São Paulo)
+ Israel (Tel Aviv)
+ Kanada West (Calgary)

# Richten Sie eine mobile Anwendung für die Verwendung von CloudWatch RUM ein
<a name="CloudWatch-RUM-web-mobile"></a>

Um mobile Anwendungen zu überwachen, erstellen Sie einen App-Monitor, konfigurieren ihn für mobile Plattformen und integrieren das AWS Distro for OpenTelemetry (ADOT) SDK in Ihre Anwendung. Mobile RUM verwendet das OpenTelemetry Protokoll (OTLP), um Telemetriedaten an einen speziellen OTLP-Endpunkt zu senden. 

## Um einen App-Monitor für eine mobile Plattform zu erstellen
<a name="mobile-platform-app-monitor"></a>

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie **Add app monitor** (App-Überwachung hinzufügen) aus.

1. Geben Sie unter **Name des App-Monitors** einen Namen ein, der zur Identifizierung dieses App-Monitors in der CloudWatch RUM-Konsole verwendet werden soll.

1. Wählen Sie **Android** oder **iOS** als Plattform aus.

1. Unter **Datenspeicher** können Sie auswählen, ob Kopien von RUM-OTEL-Protokollereignissen und -Spans in CloudWatch Logs gespeichert werden sollen, und die Aufbewahrung konfigurieren. Standardmäßig speichert die Protokollgruppe CloudWatch Logs die Daten 30 Tage lang. Sie können den Aufbewahrungszeitraum in der CloudWatch Logs-Konsole anpassen.

1. (Optional) Wählen Sie unter **Ressourcenbasierte Richtlinie** aus, ob Sie eine ressourcenbasierte Richtlinie hinzufügen möchten, um zu steuern, wer Anfragen an Ihren App Monitor senden kann. Wenn Sie **Öffentliche Richtlinie erstellen** auswählen, wird eine Ressourcenrichtlinie angehängt, die es jedem ermöglicht, Anfragen an Ihren App Monitor zu senden. Weitere Informationen finden Sie unter [Verwendung ressourcenbasierter Richtlinien mit RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Um die AWS Röntgenverfolgung von Benutzersitzungen in Stichproben zu aktivieren, wählen Sie **Aktives Tracing** und dann **Meinen Service mit X-Ray verfolgen** aus. AWS 

   Wenn diese Option ausgewählt ist, werden OTEL-Spans, die während der Benutzersitzungen mit Stichproben generiert wurden, nachverfolgt. Sie können dann die Traces und Spans dieser Sessions im RUM-Dashboard sowie auf den Seiten mit der X-Ray-Trace-Map und den Trace-Details sehen. Diese Benutzersitzungen werden auch als Client-Seiten in Application Signals angezeigt, nachdem Sie sie für Ihre Anwendung aktiviert haben.

1. (Optional) So fügen Sie dem App-Monitor Tags hinzu:

   1. Wählen Sie „**Tags**“, „**Neues Tag hinzufügen**“.

   1. Geben Sie unter **Schlüssel** einen Namen für das Tag ein. Sie können im Feld Wert einen optionalen **Wert** hinzufügen.

   1. (Optional) Zum Hinzufügen eines weiteren Tags wählen Sie **Add new tag** (Neues Tag hinzufügen) erneut aus.

   Weitere Informationen finden Sie unter [AWS Tagging-Ressourcen](https://docs.aws.amazon.com/tagging/latest/userguide/tagging-resources.html) im *AWS Tagging- und Tag-Editor-Benutzerhandbuch*.

1. Wählen Sie **Add app monitor** (App-Überwachung hinzufügen) aus.

1. Im Abschnitt **Beispielcode** können Sie den Codeausschnitt kopieren, um ihn Ihrer Anwendung hinzuzufügen. Mit dem AWS Distro for OpenTelemetry (ADOT) SDK können Sie zwischen **manueller Instrumentierung zur Konfiguration der Überwachung in Ihrem Anwendungscode und Zero-Code-Instrumentation** **wählen, für die nur minimale Konfigurationsänderungen erforderlich** sind.

   Sowohl für Android- als auch für iOS-Anwendungen ist Zero-Code Instrumentation die einfachste Option, da sie die Telemetrieerfassung automatisch mithilfe einer Konfigurationsdatei initialisiert. Die manuelle Instrumentierung gibt Ihnen mehr Kontrolle über den Initialisierungs- und Konfigurationsprozess.

1. Wählen Sie **Copy** (Kopieren) oder **Download** (Herunterladen), und klicken Sie dann auf **Done** (Fertig).

### Einrichtung der iOS-Anwendung
<a name="CloudWatch-RUM-ios-setup"></a>

Integrieren Sie für iOS-Anwendungen das [AWS Distro for OpenTelemetry (ADOT) iOS SDK](https://github.com/aws-observability/aws-otel-swift), um die RUM-Überwachung zu ermöglichen. Das SDK unterstützt iOS 16 und spätere Versionen und bietet automatische Instrumentierung für gängige Leistungsszenarien.

### Einrichtung der Android-Anwendung
<a name="CloudWatch-RUM-android-setup"></a>

Integrieren Sie für Android-Anwendungen das [Android SDK von AWS Distro for OpenTelemetry (ADOT)](https://github.com/aws-observability/aws-otel-android), um die RUM-Überwachung zu ermöglichen. Das SDK bietet automatische Instrumentierung und unterstützt sowohl signierte als auch unsignierte Authentifizierungsmodelle.

## Authentifizierung und Sicherheit
<a name="CloudWatch-RUM-authentication"></a>

Mobile RUM unterstützt flexible Authentifizierungsmodelle, wie sie in ihren definiert sind SDKs.
+ iOS-Anwendungen verwenden das [AWS Distro for OpenTelemetry (ADOT) iOS SDK](https://github.com/aws-observability/aws-otel-swift). 
+ Android-Anwendungen verwenden das [AWS Distro for OpenTelemetry (ADOT](https://github.com/aws-observability/aws-otel-android)) Android SDK.

# IAM-Richtlinien für die Verwendung von RUM CloudWatch
<a name="CloudWatch-RUM-permissions"></a>

Um CloudWatch RUM vollständig verwalten zu können, müssen Sie als IAM-Benutzer oder als IAM-Rolle angemeldet sein, für die die **AmazonCloudWatchRUMFullAccess** IAM-Richtlinie gilt. Darüber hinaus benötigen Sie möglicherweise andere Richtlinien oder Berechtigungen:
+ Um einen App-Monitor zu erstellen, der einen neuen Amazon Cognito Cognito-Identitätspool für die Autorisierung erstellt, benötigen Sie die **Admin-IAM-Rolle** oder die **AdministratorAccess**IAM-Richtlinie.
+ Um einen App-Monitor zu erstellen, der Daten an CloudWatch Logs sendet, müssen Sie bei einer IAM-Rolle oder -Richtlinie angemeldet sein, die über die folgenden Berechtigungen verfügt:

  ```
  {
      "Effect": "Allow",
      "Action": [
          "logs:PutResourcePolicy"
      ],
      "Resource": [
          "*"
      ]
  }
  ```
+ Um JavaScript Quellkarten in einem App-Monitor zu aktivieren, müssen Sie Ihre Quellzuordnungsdateien in einen Amazon S3 S3-Bucket hochladen. Ihre IAM-Rolle oder -Richtlinie benötigt spezielle Amazon-S3-Berechtigungen, die das Erstellen von Amazon-S3-Buckets, das Festlegen von Bucket-Richtlinien und das Verwalten von Dateien im Bucket ermöglichen. Aus Sicherheitsgründen sollten Sie diese Berechtigungen auf bestimmte Ressourcen beschränken. Die folgende Beispielrichtlinie schränkt den Zugriff auf Buckets ein, deren Namen `rum` enthalten, und verwendet den `aws:ResourceAccount`-Bedingungsschlüssel, um die Berechtigungen nur auf das Hauptkonto zu beschränken.

  ```
  {
      "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}"
          }
      }
  }
  ```
+ Um Ihre eigenen AWS KMS Schlüssel für die serverseitige Verschlüsselung in Ihrem Quellzuordnungs-Bucket zu verwenden, benötigt Ihre IAM-Rolle oder -Richtlinie bestimmte AWS KMS Berechtigungen, die es ermöglichen, einen Schlüssel zu erstellen, die Schlüsselrichtlinie zu aktualisieren, den AWS KMS Schlüssel mit Amazon S3 zu verwenden und die Verschlüsselungskonfiguration Ihres Amazon S3 S3-Buckets festzulegen. Aus Sicherheitsgründen sollten Sie diese Berechtigungen auf bestimmte Zwecke beschränken. Das folgende Beispiel schränkt den Zugriff auf Schlüssel für eine bestimmte Region und accountId ein und hat ähnliche S3-Einschränkungen wie das obige Beispiel. 

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

Anderen Benutzern, die CloudWatch RUM-Daten einsehen, aber keine CloudWatch RUM-Ressourcen erstellen müssen, kann die **AmazonCloudWatchRUMReadOnlyAccess**Richtlinie gewährt werden.

# Richten Sie eine Webanwendung für die Verwendung von CloudWatch RUM ein
<a name="CloudWatch-RUM-get-started"></a>

Gehen Sie wie in diesen Abschnitten beschrieben vor, um Ihre Webanwendung so einzurichten, dass sie mit CloudWatch RUM beginnen kann, um Leistungsdaten aus realen Benutzersitzungen zu sammeln.

**Topics**
+ [Autorisieren Sie Ihre Webanwendung zum Senden von Daten an AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Einen CloudWatch RUM-App-Monitor für eine Webanwendung erstellen](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Ändern des Codeausschnitts zur Konfiguration des CloudWatch RUM-Webclients (optional)](CloudWatch-RUM-modify-snippet.md)
+ [Fügen Sie den CloudWatch App-Monitor-Codeausschnitt in Ihre Anwendung ein](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Testen Sie Ihr CloudWatch App Monitor-Setup, indem Sie Benutzerereignisse generieren](CloudWatch-RUM-get-started-generate-data.md)

# Autorisieren Sie Ihre Webanwendung zum Senden von Daten an AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Sie haben vier Möglichkeiten zum Einrichten der Datenauthentifizierung:
+ Verwenden Sie Amazon Cognito und lassen Sie CloudWatch RUM einen neuen Amazon Cognito Cognito-Identitätspool für die Anwendung erstellen. Diese Methode erfordert den geringsten Aufwand für die Einrichtung.

  Der Identitätspool enthält eine nicht authentifizierte Identität. Auf diese Weise kann der CloudWatch RUM-Webclient Daten an CloudWatch RUM senden, ohne den Benutzer der Anwendung zu authentifizieren.

  Der Amazon-Cognito-Identitätspool hat eine angehängte IAM-Rolle. Die nicht authentifizierte Identität von Amazon Cognito ermöglicht es dem Webclient, die IAM-Rolle zu übernehmen, die berechtigt ist, Daten an RUM zu senden. CloudWatch 
+ Verwenden Sie Amazon Cognito für die Authentifizierung. Wenn Sie das verwenden, können Sie einen vorhandenen Amazon Cognito-Identitätspool nutzen oder einen neuen erstellen, um ihn mit dieser App-Überwachung zu verwenden. Wenn Sie einen vorhandenen Identitätspool verwenden, müssen Sie auch die IAM-Rolle ändern, die an den Identitätspool angehängt ist. Verwenden Sie diese Option für Identitätspools, die nicht authentifizierte Benutzer unterstützen. Sie können Identitätspools nur in der gleichen Region verwenden.
+ Verwenden Sie die Authentifizierung von einem vorhandenen Identitätsanbieter, den Sie bereits eingerichtet haben. In diesem Fall müssen Sie Anmeldeinformationen vom Identitätsanbieter abrufen, und Ihre Anwendung muss diese Anmeldeinformationen an den RUM-Webclient weiterleiten.

  Verwenden Sie diese Option für Identitätspools, die nur authentifizierte Benutzer unterstützen.
+ Verwenden Sie ressourcenbasierte Richtlinien, um den Zugriff auf Ihrer App-Überwachung zu verwalten. Dies beinhaltet die Möglichkeit, nicht authentifizierte Anfragen ohne Anmeldeinformationen an RUM zu senden. CloudWatch AWS Weitere Informationen zu ressourcenbasierten Richtlinien und RUM finden Sie unter [Verwendung ressourcenbasierter Richtlinien mit RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

In den folgenden Abschnitten werden diese Optionen ausführlich erörtert.

## Verwenden Sie einen vorhandenen Amazon-Cognito-Identitätspool.
<a name="CloudWatch-RUM-get-started-authorization-existingcognito"></a>

Wenn Sie sich für die Verwendung eines Amazon Cognito Cognito-Identitätspools entscheiden, geben Sie den Identitätspool an, wenn Sie die Anwendung zu CloudWatch RUM hinzufügen. Der Pool muss die Aktivierung des Zugriffs auf nicht authentifizierte Identitäten unterstützen. Sie können Identitätspools nur in der gleichen Region verwenden.

Sie müssen auch die folgenden Berechtigungen zur IAM-Richtlinie hinzufügen, die an die IAM-Rolle angehängt ist, die mit diesem Identitätspool verknüpft ist.

------
#### [ 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 sendet dann das erforderliche Sicherheitstoken, damit Ihre Anwendung auf CloudWatch RUM zugreifen kann.

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

Wenn Sie sich für die Nutzung einer privaten Authentifizierung von einem Drittanbieter entscheiden, müssen Sie Anmeldeinformationen vom Identitätsanbieter abrufen und an AWS weiterleiten. Am besten kann dies mit einem *Sicherheits-Token-Anbieter* durchgeführt werden. Sie können jeden Anbieter von Sicherheitstoken verwenden, einschließlich Amazon Cognito mit AWS -Security-Token-Service. Weitere Informationen zu finden Sie AWS STS unter [Willkommen bei der AWS -Security-Token-Service API-Referenz.](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) 

Wenn Sie Amazon Cognito in diesem Szenario als Token-Anbieter verwenden möchten, können Sie Amazon Cognito so konfigurieren, dass es mit einem Authentifizierungsanbieter zusammenarbeitet. Weitere Informationen erhalten Sie unter [Erste Schritte mit Amazon-Cognito-Identitätenpools (Verbundidentitäten)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html).

Nachdem Sie Amazon Cognito für die Zusammenarbeit mit Ihrem Identitätsanbieter konfiguriert haben, müssen Sie wie folgt vorgehen:
+ Erstellen Sie eine IAM-Rolle mit den folgenden Berechtigungen. Ihre Anwendung verwendet diese Rolle für den Zugriff auf AWS.

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

****  

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

------
+ Fügen Sie Ihrer Anwendung Folgendes hinzu, damit sie die Anmeldeinformationen von Ihrem Anbieter an CloudWatch RUM weiterleitet. Fügen Sie die Zeile so ein, dass sie ausgeführt wird, nachdem sich ein Benutzer bei Ihrer Anwendung angemeldet hat und die Anwendung die Anmeldeinformationen für den Zugriff auf AWS erhalten hat.

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

Weitere Informationen zu Anmeldeinformationsanbietern im AWS JavaScript SDK finden Sie unter [Einrichten von Anmeldeinformationen in einem Webbrowser](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) im v3-Entwicklerhandbuch für SDK for JavaScript, [Einrichten von Anmeldeinformationen in einem Webbrowser](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) im v2-Entwicklerhandbuch für SDK for JavaScript, und [@aws -sdk/credentials](https://www.npmjs.com/package/@aws-sdk/credential-providers) al-providers. 

Sie können auch das SDK für den CloudWatch RUM-Webclient verwenden, um die Webclient-Authentifizierungsmethoden zu konfigurieren. Weitere Informationen zum Webclient-SDK finden Sie unter [CloudWatch RUM-Webclient-SDK](https://github.com/aws-observability/aws-rum-web). 

# Einen CloudWatch RUM-App-Monitor für eine Webanwendung erstellen
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Um mit der Verwendung von CloudWatch RUM mit Ihrer Anwendung zu beginnen, erstellen Sie einen *App-Monitor*. Wenn der App-Monitor erstellt wird, generiert RUM einen Codeausschnitt, den Sie in Ihre Anwendung einfügen können. Das Snippet ruft den RUM-Client-Code ab. Der RUM-Client erfasst Daten aus den Benutzersitzungen Ihrer Anwendung und sendet sie an RUM.

## Um einen App-Monitor für eine Webplattform zu erstellen
<a name="web-platform-app-monitor"></a>

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie **Add app monitor** (App-Überwachung hinzufügen) aus.

1. Geben Sie unter **Name des App-Monitors** einen Namen ein, der zur Identifizierung dieses App-Monitors in der CloudWatch RUM-Konsole verwendet werden soll.

1. Wählen Sie **Web** als Plattform aus.

1. Geben Sie für **Domainliste der Anwendung** die registrierten Domainnamen ein, unter denen Ihre Anwendung über Verwaltungsberechtigung verfügt. Sie können auch ein Platzhalterzeichen `*` verwenden, um jede Subdomain oder Top-Level-Domains (z. B. \$1.amazon.com, amazon.\$1, \$1.amazon.\$1) zuzulassen.

1. Geben Sie für **Configure RUM data collection** (RUM-Datensammlung konfigurieren) an, ob die App-Überwachung alle folgenden Aspekte sammeln soll:
   + **Performance-Telemetrie** – Sammelt Informationen über Seitenlade- und Ressourcenladezeiten
   + **JavaScript Fehler** — Sammelt Informationen über unbehandelte JavaScript Fehler, die von Ihrer Anwendung verursacht wurden

     Sie können **Unminify JavaScript Error-Stack-Traces auswählen, um nicht minimierte Fehler** zu debuggen. JavaScript Um dieses Feature zu nutzen, laden Sie Ihre Quellkartendateien in einen Amazon-S3-Bucket oder -Ordner hoch und geben Sie die Amazon-S3-URI an. Nach der Aktivierung verwendet RUM diese Quellzuordnungen und bereichert JavaScript Fehlerereignisse durch Hinzufügen des nicht minimierten Stack-Trace. Beachten Sie, dass diese Funktion nach der Aktivierung nur neue JavaScript Fehlerereignisse verarbeitet und nicht für zuvor gesammelte Daten verwendet werden kann. Weitere Informationen finden Sie unter [Aktivierung der Entminimierung von JavaScript Error-Stack-Traces](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **HTTP-Fehler** – Sammelt Informationen über HTTP-Fehler, die von Ihrer Anwendung ausgegeben werden

   Wenn Sie diese Optionen auswählen, erhalten Sie mehr Informationen zu Ihrer Anwendung, es werden jedoch auch mehr CloudWatch RUM-Ereignisse generiert, sodass mehr Gebühren anfallen.

   Wenn Sie keine dieser Optionen auswählen, erfasst der App Monitor dennoch Ereignisse und Seiten zum Sitzungsstart, IDs sodass Sie sehen können, wie viele Benutzer Ihre Anwendung verwenden, einschließlich Aufschlüsselungen nach Betriebssystemtyp und -version, Browsertyp und -version, Gerätetyp und Standort.

1. Wählen Sie **Diese Option aktivieren, damit der CloudWatch RUM-Webclient Cookies setzen** kann, wenn Sie Benutzer IDs und Sitzung anhand IDs von Stichproben von Benutzersitzungen erfassen möchten. Die Benutzer IDs werden nach dem Zufallsprinzip von RUM generiert. Weitere Informationen finden Sie unter [CloudWatch RUM-Webclient-Cookies (oder ähnliche Technologien)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. Geben Sie für **Session samples** (Sitzungsbeispiele) den Prozentsatz der Benutzersitzungen ein, die zum Sammeln von RUM-Daten verwendet werden. Der Standardwert ist 100 %. Wenn Sie diese Zahl reduzieren, erhalten Sie weniger Daten und die Gebühren sinken. Weitere Informationen zu den Preisen für RUM erhalten Sie unter [RUM – Preise](CloudWatch-RUM.md#RUMpricing).

1. Endbenutzerdaten, die Sie für CloudWatch RUM sammeln, werden 30 Tage lang aufbewahrt und anschließend gelöscht. Wenn Sie Kopien von RUM-Ereignissen in CloudWatch Logs speichern und konfigurieren möchten, wie lange diese Kopien aufbewahrt werden sollen, wählen Sie **Diese Option aktivieren, um Ihre Anwendungstelemetriedaten in Ihrem CloudWatch Logs-Konto unter **Datenspeicher** zu speichern**. Standardmäßig speichert die Protokollgruppe CloudWatch Logs die Daten 30 Tage lang. Sie können den Aufbewahrungszeitraum in der CloudWatch Logs-Konsole anpassen.

1. (Optional) Fügen Sie Ihrer App-Überwachung eine ressourcenbasierte Richtlinie hinzu, um zu steuern, wer `PutRumEvents`-Anforderungen an Ihre App-Überwachung senden kann. Wenn Sie **Öffentliche Richtlinie erstellen** wählen, wird eine Ressourcenrichtlinie an Ihre App-Überwachung angehängt, die es jedem ermöglicht, `PutRumEvents`-Anforderungen an Ihre App-Überwachung zu senden. Weitere Informationen zu dieser Methode finden Sie unter [Verwendung ressourcenbasierter Richtlinien mit RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Wenn Sie im vorherigen Schritt eine ressourcenbasierte Richtlinie angehängt haben, müssen Sie Anfragen an CloudWatch RUM nicht mit AWS Anmeldeinformationen signieren, und Sie können die Einrichtung der Autorisierung überspringen. Geben Sie ansonsten für **Autorisierung** an, ob Sie einen neuen oder vorhandenen Amazon-Cognito-Identitätspool oder einen anderen Identitätsanbieter verwenden möchten. Das Erstellen eines neuen Identitätspools ist die einfachste Option, die keine anderen Einrichtungsschritte erfordert. Weitere Informationen hierzu finden Sie unter [Autorisieren Sie Ihre Webanwendung zum Senden von Daten an AWS](CloudWatch-RUM-get-started-authorization.md).

   Das Erstellen eines neuen Amazon-Cognito-Identitätspools erfordert Administratorberechtigungen. Weitere Informationen finden Sie unter [IAM-Richtlinien für die Verwendung von RUM CloudWatch](CloudWatch-RUM-permissions.md).

1. (Optional) Wenn Sie den RUM-Codeausschnitt zu Ihrer Anwendung hinzufügen, fügt der Webclient das JavaScript Tag zur Überwachung der Nutzung standardmäßig in den HTML-Code aller Seiten Ihrer Anwendung ein. Um dies zu ändern, wählen Sie **Configure pages** (Seiten konfigurieren) und anschließend entweder **Include only these pages** (Nur diese Seiten einschließen) oder **Exclude these pages** (Diese Seiten ausschließen) aus. Geben Sie dann die Seiten an, die ein- oder ausgeschlossen werden sollen. Um eine Seite anzugeben, die ein- oder ausgeschlossen werden soll, geben Sie die vollständige Seite ein. URLs Um zusätzliche Seiten anzugeben, wählen Sie **Add URL** (URL hinzufügen) aus.

1. Um die AWS X-Ray Ablaufverfolgung der Benutzersitzungen zu aktivieren, die vom App Monitor erfasst werden, wählen Sie **Aktives Tracing** und dann **Meinen Service verfolgen** mit aus. AWS X-Ray

   Wenn Sie diese Auswahl treffen, werden `XMLHttpRequest`- und `fetch`-Anforderungen, die während Benutzersitzungen, die von der App-Überwachung im Rahmen einer Stichprobe ausgewählt werden, nachverfolgt. Sie sehen dann Ablaufverfolgungen und Segmente aus diesen Benutzersitzungen im RUM-Dashboard sowie die X-Ray-Trace-Karte und die Trace-Detailseiten. Diese Benutzersitzungen werden auch als Client-Seiten in [Application Signals](CloudWatch-Application-Monitoring-Sections.md) angezeigt, nachdem Sie sie für Ihre Anwendung aktiviert haben.

   Indem Sie zusätzliche Konfigurationsänderungen am CloudWatch RUM-Webclient vornehmen, können Sie HTTP-Anfragen einen X-Ray-Trace-Header hinzufügen, um die end-to-end Nachverfolgung von Benutzersitzungen bis hin zu nachgeschalteten AWS Managed Services zu ermöglichen. Weitere Informationen finden Sie unter [X-Ray end-to-end Tracing aktivieren](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Optional) Um Tags zur App-Überwachung hinzuzufügen, wählen Sie **Tags** (Tags), **Add new tag** (Neues Tag hinzufügen) aus.

   Geben Sie für **Key** (Schlüssel) einen Namen für das Tag ein. Sie können einen optionalen Wert für das Tag unter **Value** (Wert) hinzufügen. 

   (Optional) Zum Hinzufügen eines weiteren Tags wählen Sie **Add new tag** (Neues Tag hinzufügen) erneut aus.

   Weitere Informationen finden Sie unter [Markieren von AWS -Ressourcen](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).

1. Wählen Sie **Add app monitor** (App-Überwachung hinzufügen) aus.

1. Im Abschnitt **Sample code** (Beispiel-Code) können Sie den Codeausschnitt kopieren, um ihn in Ihre Anwendung einzufügen. Wir empfehlen, dass Sie **JavaScript**oder wählen **TypeScript**und NPM verwenden, CloudWatch um den RUM-Webclient als JavaScript Modul zu installieren.

   Alternativ können Sie **HTML** wählen, um ein Content Delivery Network (CDN) zur Installation des CloudWatch RUM-Webclients zu verwenden. Der Nachteil der Verwendung eines CDN ist, dass der Webclient oft von Werbeblockern blockiert wird.

1. Wählen Sie **Copy** (Kopieren) oder **Download** (Herunterladen), und klicken Sie dann auf **Done** (Fertig).

# Ändern des Codeausschnitts zur Konfiguration des CloudWatch RUM-Webclients (optional)
<a name="CloudWatch-RUM-modify-snippet"></a>

Sie können den Codeausschnitt ändern, bevor Sie ihn in Ihre Anwendung einfügen, um mehrere Optionen zu aktivieren oder zu deaktivieren. Weitere Informationen finden Sie in der [ CloudWatch RUM-Webclient-Dokumentation](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).

Es gibt vier Konfigurationsoptionen, die Sie unbedingt beachten sollten, wie in diesen Abschnitten beschrieben.

## Verhinderung der Erfassung von Ressourcen URLs , die persönliche Informationen enthalten könnten
<a name="CloudWatch-RUM-resourceURL"></a>

Standardmäßig ist der CloudWatch RUM-Webclient so konfiguriert, dass er die URLs von der Anwendung heruntergeladenen Ressourcen aufzeichnet. Zu diesen Ressourcen gehören HTML-Dateien, Bilder, JavaScript CSS-Dateien, Dateien usw. Bei einigen Anwendungen URLs können sie persönlich identifizierbare Informationen (PII) enthalten.

Wenn dies bei Ihrer Anwendung der Fall ist, empfehlen wir Ihnen dringend, die Erfassung von Ressourcen zu deaktivieren, URLs indem Sie dies `recordResourceUrl: false` in der Konfiguration des Codeausschnitts festlegen, bevor Sie sie in Ihre Anwendung einfügen.

## Manuelle Aufzeichnung von Seitenaufrufen
<a name="CloudWatch-RUM-pageload"></a>

Standardmäßig zeichnet der Webclient Seitenaufrufe auf, wenn die Seite zum ersten Mal geladen wird und wenn die Browser-Verlaufs-API aufgerufen wird. Die Standardseiten-ID ist `window.location.pathname`. In manchen Fällen möchten Sie dieses Verhalten jedoch außer Kraft setzen und die Anwendung so instrumentieren, dass die Seitenaufrufe programmatisch aufgezeichnet werden. Auf diese Weise haben Sie die Kontrolle über die Seiten-ID und den Zeitpunkt ihrer Aufzeichnung. Nehmen wir zum Beispiel eine Webanwendung, die eine URI mit einer variablen ID hat, wie `/entity/123` oder `/entity/456`. Standardmäßig generiert CloudWatch RUM für jeden URI ein Seitenaufrufereignis mit einer eindeutigen Seiten-ID, die dem Pfadnamen entspricht. Möglicherweise möchten Sie sie jedoch stattdessen nach derselben Seiten-ID gruppieren. Deaktivieren Sie dazu in der `disableAutoPageView`-Konfiguration die Automatisierung der Seitenansicht des Webclients und verwenden Sie den Befehl `recordPageView` zum Festlegen der gewünschten Seiten-ID. Weitere Informationen finden Sie unter [Anwendungsspezifische Konfigurationen](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md) unter. GitHub

**Beispiel für eingebettetes Skript:**

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

**JavaScript Beispiel für ein Modul:**

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

## X-Ray end-to-end Tracing aktivieren
<a name="CloudWatch-RUM-xraytraceheader"></a>

Wenn Sie die App-Überwachung erstellen, wählen Sie **Meinen Service nachverfolgen mit AWS X-Ray** aus. Dies ermöglicht das Nachverfolgen von `XMLHttpRequest`- und `fetch`-Anforderungen, die während Benutzersitzungen gestellt werden, die von der App-Überwachung als Stichprobe ausgewählt werden. Sie können dann die Traces dieser HTTP-Anfragen im CloudWatch RUM-Dashboard sowie auf den Seiten X-Ray Trace Map und Trace-Details sehen.

Standardmäßig sind diese clientseitigen Ablaufverfolgungen nicht mit nachgelagerten serverseitigen Ablaufverfolgungen verbunden. Um clientseitige Traces mit serverseitigen Traces zu verbinden und end-to-end Tracing zu aktivieren, setzen Sie die `addXRayTraceIdHeader` Option `true` im Webclient auf. Dadurch fügt der CloudWatch RUM-Webclient HTTP-Anfragen einen X-Ray-Trace-Header hinzu.

Der folgende Codeblock zeigt ein Beispiel für das Hinzufügen clientseitiger Ablaufverfolgungen. Einige Konfigurationsoptionen werden aus diesem Beispiel zu Gunsten der Lesbarkeit weggelassen.

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

**Warnung**  
Wenn Sie den CloudWatch RUM-Webclient so konfigurieren, dass er HTTP-Anfragen einen X-Ray-Trace-Header hinzufügt, kann dies dazu führen, dass Cross-Origin Resource Sharing (CORS) fehlschlägt oder die Signatur der Anfrage ungültig wird, wenn die Anfrage mit Sigv4 signiert ist. Weitere Informationen finden Sie in der [ CloudWatch RUM-Webclient-Dokumentation](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md). Wir empfehlen dringend, Ihre Anwendung zu testen, bevor Sie einen clientseitigen X-Ray-Ablaufverfolgungs-Header in einer Produktionsumgebung hinzufügen.

Weitere Informationen finden Sie in der [ CloudWatch RUM-Webclient-Dokumentation](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http)

## Senden von unsignierten Anfragen an RUM CloudWatch
<a name="CloudWatch-RUM-unsigned"></a>

Standardmäßig signiert der RUM-Webclient alle an RUM gesendeten Anforderungen. Wenn Sie `signing:false` in der Client-Konfiguration festgelegt haben, werden Anfragen unsigniert, wenn sie an CloudWatch RUM gesendet werden. Daten werden nur dann in RUM aufgenommen, wenn eine auf öffentlichen Ressourcen basierende Richtlinie an die App-Überwachung angehängt ist. Weitere Informationen finden Sie unter [Verwendung ressourcenbasierter Richtlinien mit RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

# Fügen Sie den CloudWatch App-Monitor-Codeausschnitt in Ihre Anwendung ein
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

Als Nächstes fügen Sie den Codeausschnitt, den Sie im vorherigen Abschnitt erstellt haben, in Ihre Anwendung ein.

**Warnung**  
Der Webclient, der durch den Codeausschnitt heruntergeladen und konfiguriert wurde, verwendet Cookies (oder ähnliche Technologien), um Ihnen bei der Erfassung von Endbenutzerdaten zu helfen. Bevor Sie den Codeausschnitt einfügen, sehen Sie sich [Filtern nach Metadatenattributen in der KonsoleDatenschutz und Datenschutz bei RUM CloudWatch](CloudWatch-RUM-privacy.md) an.

Wenn Sie den zuvor generierten Codeausschnitt nicht haben, finden Sie ihn, indem Sie den Anweisungen in [Wie finde ich einen Codeausschnitt, den ich bereits generiert habe?](CloudWatch-RUM-find-code-snippet.md) folgen.

**Um den CloudWatch RUM-Codeausschnitt in Ihre Anwendung einzufügen**

1. Fügen Sie den Codeausschnitt, den Sie im vorherigen Abschnitt kopiert oder heruntergeladen haben, in das `<head>`-Element Ihrer Anwendung ein. Fügen Sie ihn vor dem `<body>`-Element oder anderen `<script>`-Tags ein.

   Beispiel für einen generierten Codeausschnitt:

   ```
   <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. Wenn es sich bei Ihrer Anwendung um eine mehrseitige Webanwendung handelt, müssen Sie Schritt 1 für jede HTML-Seite wiederholen, die in die Datenerfassung aufgenommen werden soll.

# Testen Sie Ihr CloudWatch App Monitor-Setup, indem Sie Benutzerereignisse generieren
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Nachdem Sie den Codeausschnitt eingefügt haben und Ihre aktualisierte Anwendung ausgeführt wird, können Sie sie testen, indem Sie Benutzerereignisse manuell generieren. Wir empfehlen für den Test Folgendes: Für diesen Test fallen die üblichen RUM-Gebühren an. CloudWatch 
+ Navigieren Sie zwischen Seiten in Ihrer Webanwendung.
+ Erstellen Sie mehrere Benutzersitzungen mit verschiedenen Browsern und Geräten.
+ Stellen Sie Anforderungen.
+  JavaScript Fehler verursachen.

Nachdem Sie einige Ereignisse generiert haben, können Sie sie im CloudWatch RUM-Dashboard anzeigen. Weitere Informationen finden Sie unter [Das CloudWatch RUM-Dashboard anzeigen](CloudWatch-RUM-view-data.md).

Es kann bis zu 15 Minuten dauern, bis Daten aus Benutzersitzungen im Dashboard angezeigt werden.

Wenn 15 Minuten nach dem Generieren von Ereignissen in der Anwendung keine Daten angezeigt werden, ziehen Sie [Problembehebung bei RUM CloudWatch](CloudWatch-RUM-troubleshooting.md) zurate.

# Verwendung ressourcenbasierter Richtlinien mit RUM CloudWatch
<a name="CloudWatch-RUM-resource-policies"></a>

Sie können eine Ressourcenrichtlinie an einen CloudWatch RUM-App-Monitor anhängen. Standardmäßig ist App-Monitoren keine Ressourcenrichtlinie zugeordnet. CloudWatch Auf Ressourcen basierende RUM-Richtlinien unterstützen keinen kontenübergreifenden Zugriff.

Weitere Informationen zu AWS Ressourcenrichtlinien finden Sie unter [Identitätsbasierte Richtlinien und ressourcenbasierte Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).

Weitere Informationen dazu, wie Ressourcen- und Identitätsrichtlinien ausgewertet werden, finden Sie unter [Richtlinien-Bewertungslogik](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html).

Weitere Informationen zur Grammatik von IAM-Richtlinien finden Sie unter [IAM-JSON-Richtlinienelementreferenz](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html).

## Unterstützte Aktionen
<a name="RUM-resource-policies-actions"></a>

Ressourcenbasierte Richtlinien auf App-Überwachungen unterstützen die `rum:PutRumEvents`-Aktion.

## Beispielrichtlinien zur Verwendung mit RUM CloudWatch
<a name="RUM-resource-policies-samples"></a>

Das folgende Beispiel ermöglicht es jedem, Daten in Ihre App-Überwachung zu schreiben, auch solche ohne SigV4-Anmeldeinformationen.

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

****  

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

------

Mithilfe des `aws:SourceIp`-Bedingungsschlüssels können Sie die Richtlinie so ändern, dass bestimmte Quell-IP-Adressen blockiert werden. In diesem Beispiel wird die Verwendung dieser Richtlinie PutRumEvents von der angegebenen IP-Adresse abgelehnt. Alle anderen Anforderungen von anderen IP-Adressen werden akzeptiert. Weitere Informationen zu diesem Bedingungsschlüssel finden Sie unter [Eigenschaften des Netzwerks](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-network-properties) im IAM-Benutzerhandbuch.

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

------

Darüber hinaus können Sie mithilfe des `rum:alias` Dienstkontextschlüssels steuern, welche Anfragen akzeptiert werden. 

Für Web-App-Monitore müssen Sie Ihren Webclient so konfigurieren, dass er `Alias` mit Version 1.20 oder höher des CloudWatch RUM-Webclients sendet, wie unter [Anwendungsspezifische](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md) Konfigurationen unter beschrieben. GitHub

Für Monitore mobiler Apps müssen Sie Ihre Instrumentierung gemäß dem SDK konfigurieren.
+ iOS-Anwendungen verwenden das [AWS Distro for OpenTelemetry (ADOT) iOS SDK](https://github.com/aws-observability/aws-otel-swift). 
+ Android-Anwendungen verwenden das [AWS Distro for OpenTelemetry (ADOT](https://github.com/aws-observability/aws-otel-android)) Android SDK.

Im folgenden Beispiel verlangt die Ressourcenrichtlinie, dass Anfragen entweder `alias1` oder enthalten müssen, `alias2` damit das Ereignis akzeptiert wird.

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

# Konfiguration des CloudWatch RUM-Webclients
<a name="CloudWatch-RUM-configure-client"></a>

Ihre Anwendungen können eines der von RUM generierten Codefragmente verwenden, um den CloudWatch CloudWatch RUM-Webclient zu installieren. Die generierten Codefragmente unterstützen zwei Installationsmethoden: als JavaScript Modul über NPM oder über ein Content Delivery Network (CDN). Um die beste Leistung zu erzielen, empfehlen wir die NPM-Installationsmethode. Weitere Informationen zur Verwendung dieser Methode finden Sie unter Als Modul [installieren](https://github.com/aws-observability/aws-rum-web/blob/main/docs/npm_installation.md). JavaScript 

Wenn Sie die CDN-Installationsoption verwenden, blockieren Werbeblocker möglicherweise das von RUM bereitgestellte Standard-CDN. CloudWatch Damit wird die Anwendungsüberwachung für Benutzer deaktiviert, die Werbeblocker installiert haben. Aus diesem Grund empfehlen wir, das Standard-CDN nur für das erste Onboarding mit RUM zu verwenden. CloudWatch Weitere Informationen zur Behebung dieses Problems finden Sie unter [Instrumentierung dieser Anwendung](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#instrument-the-application).

Der Codeausschnitt befindet sich im `<head>`-Tag einer HTML-Datei und installiert den Webclient, indem es den Webclient herunterlädt und ihn dann für die zu überwachende Anwendung konfiguriert. Der Ausschnitt ist eine selbstausführende Funktion, die wie folgt aussieht. In diesem Beispiel wurde ein Großteil der Funktion des Ausschnitts zu Gunsten der Lesbarkeit weggelassen.

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

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

Der Codeausschnitt akzeptiert sechs Argumente:
+ Ein Namespace zum Ausführen von Befehlen auf dem Webclient, wie `'cwr'`
+ Die ID der App-Überwachung, wie z. B. `'00000000-0000-0000-0000-000000000000'`
+ Die Anwendungsversion wie z. B. `'1.0.0'`
+ Die AWS Region des App-Monitors, z. B. `'us-west-2'`
+ Die URL des Web-Clients wie z. B. `'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js'`
+ Anwendungsspezifische Konfigurationsoptionen. Weitere Informationen finden Sie im folgenden Abschnitt.

## Ignorieren von Fehlern
<a name="CloudWatch-RUM-configure-ignore-errors"></a>

Der CloudWatch RUM-Webclient überwacht alle Arten von Fehlern, die in Ihren Anwendungen auftreten. Wenn Ihre Anwendung JavaScript Fehler ausgibt, die Sie nicht im CloudWatch RUM-Dashboard anzeigen möchten, können Sie den RUM-Webclient so konfigurieren, dass diese Fehler herausgefiltert werden, sodass Sie nur die relevanten Fehlerereignisse im CloudWatch RUM-Dashboard sehen. CloudWatch Sie könnten sich beispielsweise dafür entscheiden, einige JavaScript Fehler nicht im Dashboard anzuzeigen, weil Sie bereits eine Lösung für sie gefunden haben und die Menge dieser Fehler andere Fehler maskiert. Unter Umständen möchten Sie auch Fehler ignorieren, die Sie nicht beheben können, da sie mit einer Bibliothek eines Drittanbieters zusammenhängen.

Weitere Informationen zur Instrumentierung des Webclients zum Herausfiltern bestimmter JavaScript Fehler finden Sie im Beispiel unter [Fehler](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md#errors) in der Github-Dokumentation für den Webclient.

## Konfigurationsoptionen
<a name="CloudWatch-RUM-configure-options"></a>

Informationen zu den für den CloudWatch RUM-Webclient verfügbaren Konfigurationsoptionen finden Sie in der [ CloudWatch RUM-Webclient-Dokumentation](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md)

# Aktivierung der Entminimierung von JavaScript Error-Stack-Traces
<a name="CloudWatch-RUM-JavaScriptStackTraceSourceMaps"></a>

Wenn der JavaScript Quellcode Ihrer Webanwendung minimiert ist, kann es schwierig sein, Fehler-Stack-Traces zu lesen. Sie können die Entminimierung der Stack-Traces aktivieren, indem Sie Ihre Quellzuordnungen auf Amazon S3 hochladen. CloudWatch RUM ruft die Quellzuordnungen ab, um die Zeilen- und Spaltennummern im minimierten Quellcode wieder dem ursprünglichen, nicht minimierten Quellcode zuzuordnen. Das verbessert die Lesbarkeit Ihrer Fehler-Stack-Traces und hilft dabei, den Ort des Fehlers im ursprünglichen Quellcode zu identifizieren. 

## Anforderungen und Syntax
<a name="CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps"></a>

Quellkarten sind entscheidend für das Debuggen und Nachverfolgen von Problemen in Ihrer Webanwendung in verschiedenen Versionen. Stellen Sie sicher, dass jede Webanwendungsversion über eine eindeutige Quellkarte verfügt. Jede Version sollte eine eigene eindeutige releaseId haben. Eine releaseId muss eine Zeichenfolge mit einer Länge zwischen 1 und 200 Zeichen sein und darf nur Buchstaben, Zahlen, Unterstriche, Bindestriche, Doppelpunkte, Schrägstriche und Punkte enthalten. Um die `releaseId` AS-Metadaten zu RUM-Ereignissen hinzuzufügen, konfigurieren Sie den CloudWatch RUM-Webclient.

Es wird erwartet, dass es sich bei den Quellkarten um einfache JSON-Dateien handelt, die der in der [Source-Map-V3-Spezifikation](https://sourcemaps.info/spec.html) definierten Struktur folgen. Die Felder `version`, `file`, `sources`, `names` und `mappings` sind erforderlich.

Stellen Sie sicher, dass die Größe der einzelnen Quellkarten die Grenze von 50 MB nicht überschreitet. Darüber hinaus ruft der RUM-Service nur bis zu 50 MB an Quellkarten pro Stack-Trace ab. Teilen Sie den Quellcode bei Bedarf in mehrere kleinere Teile auf. Weitere Informationen finden Sie unter [Codesplitting mit WebpackJS](https://webpack.js.org/guides/code-splitting/).

**Topics**
+ [Anforderungen und Syntax](#CloudWatch-RUM-RequirementsJavaScriptStackTraceSourceMaps)
+ [Konfigurieren Sie Ihre Amazon-S3-Bucket-Ressourcenrichtlinie, um dem RUM-Service Zugriff zu gewähren](#CloudWatch-RUM-ConfigureS3)
+ [Quellkarten hochladen](#CloudWatch-RUM-UploadSourceMaps)
+ [Konfigurieren Sie ReleaseID in Ihrem CloudWatch RUM-Webclient](#CloudWatch-RUM-ConfigureRumID)
+ [CloudWatch RUM-App-Monitor aktivieren, um Stack-Traces zu deminifizieren JavaScript](#CloudWatch-RUM-unminifyjavascript)
+ [Anzeigen von nicht minimierten Stack-Traces in der RUM-Konsole](#CloudWatch-RUM-viewunminifiedstacktraces)
+ [Unminimierte Stack-Traces in Logs anzeigen CloudWatch](#CloudWatch-RUM-viewunminifiedstacktracesCWL)
+ [Fehlerbehebung bei Quellkarten](#CloudWatch-RUM-troubleshootsourcemaps)

## Konfigurieren Sie Ihre Amazon-S3-Bucket-Ressourcenrichtlinie, um dem RUM-Service Zugriff zu gewähren
<a name="CloudWatch-RUM-ConfigureS3"></a>

Stellen Sie sicher, dass sich Ihr Amazon-S3-Bucket in derselben Region wie Ihre RUM-App-Überwachung befindet. Konfigurieren Sie Ihren Amazon-S3-Bucket, um dem RUM-Service Zugriff auf das Abrufen von Quellkartendateien zu gewähren. Fügen Sie die globalen Bedingungskontextschlüssel `aws:SourceArn` und `aws:SourceAccount` hinzu, um die Berechtigungen des Services auf die Ressource zu beschränken. Dies ist der effektivste Weg, um sich vor dem [verwirrtes Stellvertreterproblem](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html) zu schützen.

Das folgende Beispiel zeigt, wie Sie die globalen Bedingungskontextschlüssel `aws:SourceArn` und `aws:SourceAccount` in Amazon S3 verwenden können, um das Problem des verwirrten Stellvertreters zu verhindern.

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

------

Wenn Sie AWS KMS Schlüssel zum Verschlüsseln der Daten verwenden, stellen Sie sicher, dass die Ressourcenrichtlinie des Schlüssels ähnlich konfiguriert ist, sodass sie die Kontextschlüssel `aws:SourceArn` und die `aws:SourceAccount` globalen Bedingungsschlüssel enthält, damit der RUM-Dienst Zugriff darauf hat, die Schlüssel zum Abrufen der Quellzuordnungsdateien zu verwenden.

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

------

## Quellkarten hochladen
<a name="CloudWatch-RUM-UploadSourceMaps"></a>

Konfigurieren Sie Ihr JavaScript Paket so, dass bei der Minimierung Quellzuordnungen generiert werden. Wenn Sie Ihre Anwendung erstellen, erstellt das Bundle ein Verzeichnis (z. B. dist), das die minimierten JavaScript Dateien und die entsprechenden Quellzuordnungen enthält. Ein Beispiel finden Sie unten.

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

Laden Sie die Quellkartendatei in Ihren Amazon-S3-Bucket hoch. Die Dateien sollten sich in einem Ordner mit der `releaseId` als Namen befinden. Wenn mein Bucket-Name beispielsweise `my-application-source-maps` lautet und die `releaseId` 2.0.0 ist, dann befindet sich die Quellkartendatei am folgenden Speicherort:

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

Um das Hochladen Ihrer Quellkarten zu automatisieren, können Sie das folgende Bash-Skript erstellen und es als Teil Ihres Build-Prozesses ausführen.

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

## Konfigurieren Sie ReleaseID in Ihrem CloudWatch RUM-Webclient
<a name="CloudWatch-RUM-ConfigureRumID"></a>

CloudWatch RUM verwendet die Konfiguration`releaseId`, um den Ordner zum Abrufen der Quellzuordnungsdateien zu ermitteln. Benennen Sie die `releaseId` genauso wie Ihren Ordner mit Quellkartendateien. Wenn Sie das oben angegebene Bash-Skript oder ein ähnliches verwendet haben, sollte das im Skript `releaseId` konfigurierte Skript mit dem in Ihrem CloudWatch RUM-Webclient konfigurierten identisch sein. Sie müssen Version 1.21.0 oder höher des CloudWatch RUM-Webclients verwenden.

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

## CloudWatch RUM-App-Monitor aktivieren, um Stack-Traces zu deminifizieren JavaScript
<a name="CloudWatch-RUM-unminifyjavascript"></a>

Um die JavaScript Stack-Traces zu deminifizieren, setzen Sie den Status des App-Monitors auf. SourceMap `ENABLED` Geben Sie die Amazon-S3-URI für den Bucket oder Ordner an, der alle Quellkarten für Ihre App-Überwachung enthält.

Wenn Quellkarten direkt im Haupt-Bucket (nicht in einem Unterordner) gespeichert werden, sollte die Amazon-S3-URI als `Amazon S3://BUCKET_NAME` formatiert werden. In diesem Fall sollten sich die Quellkartendateien am folgenden Speicherort befinden.

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

Wenn ein untergeordnetes Verzeichnis das Stammverzeichnis ist, sollte die Amazon-S3-URI als `Amazon S3://BUCKET_NAME/DIRECTORY` formatiert werden. In diesem Fall sollten sich die Quellkartendateien am folgenden Speicherort befinden.

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

## Anzeigen von nicht minimierten Stack-Traces in der RUM-Konsole
<a name="CloudWatch-RUM-viewunminifiedstacktraces"></a>

Nachdem Sie Ihre Quellzuordnungen auf Amazon S3 hochgeladen, Quellzuordnungen auf Ihrem RUM-App-Monitor aktiviert und Ihre Webanwendung mit dem im CloudWatch RUM-Webclient `releaseId` konfigurierten bereitgestellt haben, wählen Sie in der RUM-Konsole **Ereignisse** aus. Auf dieser Registerkarte werden die Rohdaten der RUM-Ereignisse angezeigt. Filtern Sie nach dem JS-Fehlerereignistyp und sehen Sie sich das neueste JS-Fehlerereignis an. Sie werden den nicht minimierten Stack-Trace im neuen `event_details.unminifiedStack`-Feld für Ereignisse sehen, die nach der Aktivierung des Features aufgenommen wurden.

## Unminimierte Stack-Traces in Logs anzeigen CloudWatch
<a name="CloudWatch-RUM-viewunminifiedstacktracesCWL"></a>

Aktivieren Sie die Speicherung von RUM-Ereignissen in den CloudWatch Protokollen, indem Sie die **Datenspeicherung** aktivieren. Nach der Aktivierung können Sie das neue Feld **event\$1details.unminifiedStack** durchsuchen. Auf diese Weise können Sie mithilfe von CloudWatch Log-Abfragen Trends analysieren und Probleme in mehreren Sitzungen miteinander verknüpfen.

## Fehlerbehebung bei Quellkarten
<a name="CloudWatch-RUM-troubleshootsourcemaps"></a>

CloudWatch RUM bietet sofort einsatzbereite Metriken zur Fehlerbehebung bei der Einrichtung Ihrer Quellenkarte. Diese Metriken werden im Metrik-Namespace namens `AWS/RUM` veröffentlicht. Alle der folgenden Metriken werden mit einer application\$1name-Dimension veröffentlicht. Der Wert dieser Dimension ist der Name der App-Überwachung. Die Metriken werden auch mit einer `aws:releaseId`-Dimension veröffentlicht. Der Wert dieser Dimension ist dem JavaScript Fehlerereignis `releaseId` zugeordnet.


| MetricName | Einheit | Description | 
| --- | --- | --- | 
|  UnminifyLineFailureCount  |  Anzahl  |  Die Anzahl der Stack-Trace-Zeilen im JS-Fehlerereignis, deren Minimierung nicht aufgehoben werden konnte. Zusätzliche Details zu dem Fehler werden der spezifischen fehlgeschlagenen Zeile im Feld event\$1details.UnminifiedStack hinzugefügt.  | 
|  UnminifyLineSuccessCount  |  Anzahl  | Die Anzahl der Stack-Trace-Zeilen im JS-Fehlerereignis, deren Minimierung erfolgreich aufgehoben wurde. | 
| UnminifyEventFailureCount | Anzahl | Die Anzahl der JS-Fehlerereignisse, bei denen die Minimierung bei keiner Zeile aufgehoben werden konnte. Zusätzliche Details zum Fehler werden im Feld event\$1details.unminifiedStack hinzugefügt. | 
| UnminifyEventSuccessCount | Anzahl | Die Anzahl der JS-Fehlerereignisse, bei denen die Minimierung bei mindestens einer Stack-Trace-Zeile erfolgreich aufgehoben wurde. | 

CloudWatch RUM kann aus verschiedenen Gründen nicht in der Lage sein, eine Zeile im Stack-Trace zu deminifizieren, einschließlich, aber nicht beschränkt auf:
+ Die entsprechende Quellkartendatei konnte aufgrund von Berechtigungsproblemen nicht abgerufen werden. Stellen Sie sicher, dass die Bucket-Ressourcenrichtlinie korrekt konfiguriert ist.
+ Die entsprechende Quellkartendatei ist nicht vorhanden. Stellen Sie sicher, dass die Quellzuordnungsdateien in den richtigen Bucket oder Ordner hochgeladen wurden, der denselben Namen hat wie die in Ihrem CloudWatch RUM-Webclient konfigurierte ReleaseID.
+ Die entsprechende Quellkartendatei ist zu groß. Teilen Sie Ihren Quellcode in kleinere Teile auf.
+ Quellkartendateien mit einer Größe von 50 MB wurden bereits für den Stack-Trace abgerufen. Reduzieren Sie die Länge des Stack-Trace, da 50 MB eine serviceseitige Beschränkung darstellen.
+ Die Quellkarte ist ungültig und konnte nicht indiziert werden. Stellen Sie sicher, dass es sich bei der Quellkarte um eine einfache JSON-Datei handelt, die der in der Source Map-V3-Spezifikation definierten Struktur folgt und die folgenden Felder enthält: Version, Datei, Quellen, Namen, Zuordnungen.
+ Die Quellkarte konnte den minimierten Quellcode nicht dem nicht minimierten Stack-Trace zuordnen. Stellen Sie sicher, dass die Quellkarte die richtige Quellkarte für die angegebene releaseId ist.

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

In diesem Abschnitt werden Strategien für die Verwendung von CloudWatch RUM mit Anwendungen in verschiedenen Regionen beschrieben.

## Meine Anwendung wird in mehreren AWS Regionen bereitgestellt
<a name="CloudWatch-RUM-Regionalization-multiple"></a>

Wenn Ihre Anwendung in mehreren AWS Regionen bereitgestellt wird, haben Sie drei Optionen:
+ Stellen Sie einen App-Monitor in einer Region, in einem Konto, für alle Regionen bereit.
+ Stellen Sie separate App-Monitore für jede Region in eindeutigen Konten bereit.
+ Stellen Sie separate App-Monitore für jede Region bereit, alles in einem Konto.

Der Vorteil der Verwendung eines App-Monitors besteht darin, dass alle Daten in einer Visualisierung zentralisiert werden und alle CloudWatch Protokolle in dieselbe Protokollgruppe unter Logs geschrieben werden. Bei einem einzelnen App-Monitor gibt es eine geringe zusätzliche Latenzzeit für Anforderungen und einen einzigen Fehlerpunkt.

Die Verwendung mehrerer App-Monitore beseitigt zwar den einzelnen Fehlerpunkt, verhindert aber, dass alle Daten in einer Visualisierung zusammengefasst werden.

### CloudWatch RUM wurde in einigen Regionen, in denen meine Anwendung bereitgestellt wird, nicht gestartet
<a name="CloudWatch-RUM-Regionalization-notavailable"></a>

CloudWatch RUM wird in vielen Regionen eingeführt und hat eine breite geografische Abdeckung. Wenn Sie CloudWatch RUM in den Regionen einrichten, in denen es verfügbar ist, können Sie die Vorteile nutzen. Endbenutzer können sich überall befinden und ihre Sitzungen werden trotzdem erfasst, wenn Sie einen App-Monitor in der Region eingerichtet haben, mit der sie sich verbinden.

 CloudWatch RUM ist jedoch noch in keiner Region China eingeführt. Sie können aus diesen Regionen keine Daten an CloudWatch RUM senden.

# Verwenden von Seitengruppen
<a name="CloudWatch-RUM-page-groups"></a>

Mithilfe von Seitengruppen können Sie verschiedene Seiten in Ihrer Anwendung miteinander verknüpfen, um aggregierte Analysen für Seitengruppen anzuzeigen. So können Sie z. B. die aggregierten Seitenladezeiten Ihrer gesamten Zielseiten anzeigen. 

Sie ordnen Seiten in Seitengruppen ein, indem Sie zu Seitenaufrufereignissen im CloudWatch RUM-Webclient ein oder mehrere Tags hinzufügen. In den folgenden Beispielen wird die Seite `/home` in den Seitengruppen `en` und `landing` platziert:

**Beispiel für eingebettetes Skript**

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

**JavaScript Beispiel für ein Modul**

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

**Anmerkung**  
Seitengruppen sind dazu gedacht, Analysen über verschiedene Seiten hinweg zu aggregieren. Informationen darüber, wie Sie `pageIds` für Ihre Anwendung definieren und manipulieren können, finden Sie im Abschnitt **Manuelles Aufzeichnen von Seitenaufrufen** in [Ändern des Codeausschnitts zur Konfiguration des CloudWatch RUM-Webclients (optional)](CloudWatch-RUM-modify-snippet.md).

# Benutzerdefinierte Metadaten angeben
<a name="CloudWatch-RUM-custom-metadata"></a>

CloudWatch RUM fügt jedem Ereignis zusätzliche Daten als Metadaten hinzu. Ereignismetadaten bestehen aus Attributen in Form von Schlüssel-Wert-Paaren. Sie können diese Attribute verwenden, um Ereignisse in der CloudWatch RUM-Konsole zu suchen oder zu filtern. Standardmäßig erstellt CloudWatch RUM einige Metadaten für Sie. Weitere Informationen zu Standard-Metadaten erhalten Sie unter [RUM-Ereignismetadaten](CloudWatch-RUM-datacollected.md#CloudWatch-RUM-datacollected-metadata).

Sie können den CloudWatch RUM-Webclient auch verwenden, um benutzerdefinierte Metadaten zu CloudWatch RUM-Ereignissen hinzuzufügen. Die benutzerdefinierten Metadaten können Sitzungsattribute und Seitenattribute enthalten.

Um benutzerdefinierte Metadaten hinzuzufügen, müssen Sie Version 1.10.0 oder höher des CloudWatch RUM-Webclients verwenden.

## Anforderungen und Syntax
<a name="CloudWatch-RUM-custom-metadata-syntax"></a>

Jedes Ereignis kann bis zu 10 benutzerdefinierte Attribute in den Metadaten enthalten. Die Syntaxanforderungen für benutzerdefinierte Attribute lauten wie folgt:
+ **Schlüssel**
  + Maximal 128 Zeichen
  + Kann alphanumerische Zeichen, Doppelpunkte (:) und Unterstriche (\$1) enthalten
  + Darf nicht mit `aws:` beginnen.
  + Darf nicht vollständig aus einem der reservierten Schlüsselwörter bestehen, die im folgenden Abschnitt aufgeführt sind. Kann diese Schlüsselwörter als Teil eines längeren Schlüsselnamens verwenden.
+ **Werte**
  + Maximal 256 Zeichen
  + Müssen Zeichenfolgen, Zahlen oder boolesche Werte sein

**Reservierte Schlüsselwörter**

Sie können die folgenden reservierten Schlüsselnamen nicht als vollständige Schlüsselnamen verwenden. Sie können die folgenden Schlüsselwörter als Teil eines längeren Schlüsselnamens, wie z. B. `applicationVersion`, verwenden.
+ `browserLanguage`
+ `browserName`
+ `browserVersion`
+ `countryCode`
+ `deviceType`
+ `domain`
+ `interaction`
+ `osName`
+ `osVersion`
+ `pageId`
+ `pageTags`
+ `pageTitle`
+ `pageUrl`
+ `parentPageId`
+ `platformType`
+ `referrerUrl`
+ `subdivisionCode`
+ `title`
+ `url`
+ `version`

**Anmerkung**  
CloudWatch RUM entfernt benutzerdefinierte Attribute aus RUM-Ereignissen, wenn ein Attribut einen ungültigen Schlüssel oder Wert enthält oder wenn das Limit von 10 benutzerdefinierten Attributen pro Ereignis bereits erreicht wurde. 

## Sitzungsattribute hinzufügen
<a name="CloudWatch-RUM-session-attributes"></a>

Wenn Sie benutzerdefinierte Sitzungsattribute konfigurieren, werden sie allen Ereignissen in einer Sitzung hinzugefügt. Sie konfigurieren Sitzungsattribute entweder während der Initialisierung des CloudWatch RUM-Webclients oder zur Laufzeit mithilfe des `addSessionAttributes` Befehls.

Beispielsweise können Sie die Version Ihrer Anwendung als Sitzungsattribut hinzufügen. Anschließend können Sie in der CloudWatch RUM-Konsole Fehler nach Version filtern, um herauszufinden, ob eine erhöhte Fehlerrate mit einer bestimmten Version Ihrer Anwendung zusammenhängt. 

**Hinzufügen eines Sitzungsattributs bei der Initialisierung, NPM-Beispiel**

Der fett gedruckte Codeabschnitt fügt das Sitzungsattribut hinzu.

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

**Hinzufügen eines Sitzungsattributs zur Laufzeit, NPM-Beispiel**

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

**Hinzufügen eines Sitzungsattributs bei der Initialisierung, Beispiel für eingebettetes Skript**

Der fett gedruckte Codeabschnitt fügt das Sitzungsattribut hinzu.

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

**Hinzufügen eines Sitzungsattributs zur Laufzeit, Beispiel für eingebettetes Skript**

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

## Seitenattribute hinzufügen
<a name="CloudWatch-RUM-page-attributes"></a>

Wenn Sie benutzerdefinierte Seitenattribute konfigurieren, werden sie allen Ereignissen in einer Sitzung hinzugefügt. Sie konfigurieren Seitenattribute entweder während der Initialisierung des CloudWatch RUM-Webclients oder zur Laufzeit mithilfe des `recordPageView` Befehls.

Beispielsweise können Sie Ihre Seitenvorlage als Seitenattribut hinzufügen. Anschließend können Sie in der CloudWatch RUM-Konsole Fehler nach Seitenvorlagen filtern, um herauszufinden, ob eine erhöhte Fehlerrate mit einer bestimmten Seitenvorlage Ihrer Anwendung verknüpft ist. 

**Hinzufügen eines Seitenattributs bei der Initialisierung, NPM-Beispiel**

Der fett gedruckte Codeabschnitt fügt das Seitenattribut hinzu.

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

**Hinzufügen eines Seitenattributs zur Laufzeit, NPM-Beispiel**

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

**Hinzufügen eines Seitenattributs bei der Initialisierung, Beispiel für eingebettetes Skript**

Der fett gedruckte Codeabschnitt fügt das Seitenattribut hinzu.

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

**Hinzufügen eines Seitenattributs zur Laufzeit, Beispiel für eingebettetes Skript**

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

## Filtern nach Metadatenattributen in der Konsole
<a name="CloudWatch-RUM-custom-attiributes-console"></a>

Verwenden Sie die Suchleiste, um die Visualisierungen in der CloudWatch RUM-Konsole mit einem beliebigen integrierten oder benutzerdefinierten Metadatenattribut zu filtern. In der Suchleiste können Sie bis zu 20 Filterbegriffe in der Form **key=value** (Schlüssel=Wert) angeben, die auf die Visualisierungen angewendet werden sollen. Um beispielsweise Daten nur für den Chrome-Browser zu filtern, könnten Sie den Filterbegriff **browserName=Chrome** (Browsername=Chrome) hinzufügen.

Standardmäßig ruft die CloudWatch RUM-Konsole die 100 häufigsten Attributschlüssel und -werte ab, die in der Dropdownliste in der Suchleiste angezeigt werden. Um weitere Metadatenattribute als Filterbegriffe hinzuzufügen, geben Sie den vollständigen Attributschlüssel und -wert in die Suchleiste ein. 

Ein Filter kann bis zu 20 Filterbegriffe enthalten und Sie können bis zu 20 Filter pro Anwendungsmonitor speichern. Wenn Sie einen Filter speichern, wird er in der Dropdownliste **Saved filters** (Gespeicherte Filter). Sie können einen gespeicherten Filter auch löschen. 

# Benutzerdefinierte Ereignisse senden
<a name="CloudWatch-RUM-custom-events"></a>

CloudWatch RUM zeichnet die unter aufgelisteten Ereignisse auf und nimmt sie auf[Vom CloudWatch RUM-Webclient gesammelte Informationen](CloudWatch-RUM-datacollected.md). Wenn Sie Version 1.12.0 oder höher des CloudWatch RUM-Webclients verwenden, können Sie zusätzliche benutzerdefinierte Ereignisse definieren, aufzeichnen und senden. Sie definieren den Namen des Ereignistyps und die zu sendenden Daten für jeden Ereignistyp, den Sie definieren. Jede benutzerdefinierte Ereignis-Nutzlast kann bis zu 6 KB groß sein.

Benutzerdefinierte Ereignisse werden nur erfasst, wenn der Anwendungsmonitor benutzerdefinierte Ereignisse aktiviert hat. Verwenden Sie die CloudWatch RUM-Konsole oder die API, um die Konfigurationseinstellungen Ihres App Monitors zu aktualisieren. [UpdateAppMonitor](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_UpdateAppMonitor.html) 

Nachdem Sie benutzerdefinierte Ereignisse aktiviert und anschließend benutzerdefinierte Ereignisse definiert und gesendet haben, können Sie nach ihnen suchen. Verwenden Sie die Registerkarte **Ereignisse** in der CloudWatch RUM-Konsole, um nach ihnen zu suchen. Suchen Sie anhand des Ereignistyps.

## Anforderungen und Syntax
<a name="CloudWatch-RUM-custom-event-syntax"></a>

Benutzerdefinierte Ereignisse bestehen aus einem Ereignistyp und Ereignisdetails. Die Anforderungen für diese sind Folgende:
+ **Ereignistyp**
  + Dies kann entweder der **type** (Typ) oder der **name** (Name) Ihres Ereignisses sein. Beispielsweise **JsError**hat der in CloudWatch RUM integrierte Ereignistyp namens den Ereignistyp`com.amazon.rum.js_error_event`.
  + Muss zwischen 1 und 256 Zeichen lang sein.
  + Kann eine Kombination aus alphanumerischen Zeichen, Unterstrichen, Bindestrichen und Punkten sein.
+ **Ereignisdetails**
  + Enthält die eigentlichen Daten, die Sie in CloudWatch RUM aufzeichnen möchten.
  + Muss ein Objekt sein, das aus Feldern und Werten besteht.

## Beispiele für die Aufzeichnung benutzerdefinierter Ereignisse
<a name="CloudWatch-RUM-custom-event-examples"></a>

Es gibt zwei Möglichkeiten, benutzerdefinierte Ereignisse im CloudWatch RUM-Webclient aufzuzeichnen. 
+ Verwenden Sie die `recordEvent` API des CloudWatch RUM-Webclients.
+ Verwenden Sie ein benutzerdefiniertes Plugin.

**Ein benutzerdefiniertes Ereignis mithilfe der `recordEvent`-API senden, NPM-Beispiel**

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

**Ein benutzerdefiniertes Ereignis mithilfe der `recordEvent`-API senden, Beispiel für eingebettetes Skript**

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

**Beispiel für das Senden eines benutzerdefinierten Ereignisses mit einem benutzerdefinierten Plugin**

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

# Das CloudWatch RUM-Dashboard anzeigen
<a name="CloudWatch-RUM-view-data"></a>

CloudWatch RUM hilft Ihnen dabei, Daten aus Benutzersitzungen über die Leistung Ihrer Anwendung zu sammeln, darunter Ladezeiten, Apdex-Score, Geräteinformationen, Geolokalisierung von Benutzersitzungen und fehlerhafte Sitzungen. All diese Informationen werden in einem Dashboard angezeigt.

So zeigen Sie das RUM-Dashboard an:

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

Die RUM-Konsole zeigt eine Listenansicht all Ihrer App-Monitore an. Die Spalte **Plattform** gibt an, ob jeder App-Monitor für Web-, Android- oder iOS-Anwendungen vorgesehen ist. Wählen Sie einen App-Monitor aus, um auf detaillierte Ansichten mit den Registerkarten **Leistung**, **Fehler**, **Sitzungen**, **Metriken** und **Konfiguration** zuzugreifen.

## Dashboard für Webanwendungen
<a name="CloudWatch-RUM-web-dashboard"></a>

Wenn Sie einen Webanwendungsmonitor auswählen, werden die folgenden Registerkarten angezeigt:
+ Die Registerkarte **Leistung** zeigt Informationen zur Seitenleistung an, einschließlich Ladezeiten, Anforderungsinformationen, Webdaten und Seitenladezeiten im Zeitverlauf. Diese Ansicht enthält interaktive Web-Vitals-Diagramme, in denen Sie die verschiedenen Perzentilwerte der wichtigsten Web-Vitals für Ihre Seiten sehen und Datenpunkte im Diagramm auswählen können, um die zugehörigen Ereignisse anzuzeigen, die von RUM erfasst wurden. CloudWatch Von dort aus können Sie entweder weitere Ereignisse im Zusammenhang mit dem Metrikanstieg untersuchen oder Seitendetails für ein ausgewähltes Ereignis anzeigen, um bestimmte Bedingungen zu identifizieren, die zu Leistungsproblemen führen.

  Auf dieser Registerkarte können Sie auch zwischen **Seitenladevorgängen**, **Anforderungen** und **Speicherort** umschalten, um weitere Informationen zur Seitenleistung zu erhalten.
+ Auf der Registerkarte **Fehler** werden Informationen zu Javascript-Fehlern angezeigt, einschließlich der von Benutzern am häufigsten gesehenen Fehlermeldung sowie der Geräte und Browser mit den meisten Fehlern. Diese Ansicht umfasst ein Histogramm der Fehler und eine Listenansicht der Fehler. Sie können die Fehlerliste nach Benutzer- und Ereignisdetails filtern. Wählen Sie eine Fehlermeldung aus, um weitere Details zu sehen.
+ Auf der Registerkarte **HTTP-Anforderungen** werden Informationen zu HTTP-Anforderungen angezeigt, einschließlich der Anforderungs-URL mit den meisten Fehlern und der Geräte und Browser mit den meisten Fehlern. Diese Registerkarte enthält ein Histogramm der Anforderungen, eine Listenansicht der Anforderungen und eine Listenansicht der Netzwerkfehler. Sie können die Listen nach Benutzer- und Ereignisdetails filtern. Wählen Sie einen Antwortcode oder eine Fehlermeldung aus, um weitere Informationen zur Anfrage bzw. zum Netzwerkfehler zu erhalten.
+ Auf der Registerkarte **Sitzungen** werden Sitzungsmetriken angezeigt. Diese Registerkarte enthält ein Histogramm der Startereignisse von Sitzungen und eine Listenansicht der Sitzungen. Sie können die Sitzungsliste nach Ereignistyp, Benutzerdetails und Ereignisdetails filtern. Wählen Sie eine **sessionId**, um weitere Details zu einer Sitzung zu sehen.
+ Auf der Registerkarte **Ereignisse** werden ein Histogramm der RUM-Ereignisse und eine Listenansicht der Ereignisse angezeigt. Sie können die Liste der Ereignisse nach Ereignistyp, Benutzerdetails und Ereignisdetails filtern. Wählen Sie ein RUM-Ereignis aus, um das Rohereignis zu sehen.
+ Die Registerkarte **Browsers & Devices** zeigt Informationen wie Leistung und Verwendung verschiedener Browser und Geräte für den Zugriff auf Ihre Anwendung an. Diese Ansicht enthält Steuerelemente zum Umschalten der Ansicht zwischen **Browsers** und **Geräte**.

  Wenn Sie den Umfang auf einen einzelnen Browser einschränken, werden die Daten nach Browserversion aufgeschlüsselt.
+ Die **User Journey** (Benutzer-Journey) zeigt die Pfade an, die Ihre Kunden verwenden, um in Ihrer Anwendung zu navigieren. Sie können sehen, auf welcher Seite Kunden in Ihrer Anwendung starten und auf welcher Seite sie die Anwendung wieder verlassen. Sie können auch die Pfade sehen, die sie einschlagen, und den Prozentsatz der Kunden, die diesen Pfaden folgen. Sie können auf einem Knoten pausieren, um weitere Details zu dieser Seite zu erhalten. Sie können einen einzelnen Pfad auswählen, um die Verbindungen zur einfacheren Anzeige hervorzuheben.
+  Auf der Registerkarte **Metriken** werden alle von Ihrem App Monitor veröffentlichten CloudWatch Standardmetriken angezeigt, darunter Performance-Web-Vitals, Fehlermetriken (JavaScript Fehler, HTTP-Fehler/Fehler), Volumen, Benutzerfluss und Apdex-Metriken. Wenn Sie erweiterte Metriken für Ihre Anwendung erstellt haben, enthält die Registerkarte auch eine Teilmenge dieser Metriken im Abschnitt „Erweiterte Metriken“. Diese Teilmenge umfasst Metriken vom Typ PageViewCount, Http4xxCount PerformanceNavigationDuration, Http5xxCount und. JsErrorCount Das Dashboard zeigt drei metrische Variationen pro Metriktyp. Da es sich um CloudWatch Metriken handelt, können Sie diesen Tab auch mit der Option Zum Dashboard **hinzufügen in Ihr eigenes Dashboard** exportieren und ihn so aktualisieren, dass er weitere Metriken enthält. 

(Optional) Auf einer der ersten sechs Registerkarten können Sie die Schaltfläche **Seiten** und anschließend eine Seite oder Seitengruppe aus der Liste auswählen. Dadurch werden die angezeigten Daten auf eine einzelne Seite oder auf eine Gruppe von Seiten Ihrer Anwendung beschränkt. Sie können auch Seiten und Seitengruppen in der Liste als Favoriten markieren.

## Dashboard für mobile Anwendungen
<a name="CloudWatch-RUM-mobile-dashboard"></a>

Wenn Sie einen Monitor für mobile Anwendungen auswählen, werden Ihnen die folgenden Tabs angezeigt:
+ Die Registerkarte **Leistung** bietet Einblicke in die Leistung Ihrer mobilen Anwendung, einschließlich Bildschirmladezeiten, App-Startzeiten (kalt und warm), Leistungskennzahlen und Apdex-Werte im Zeitverlauf. In der Detailansicht wird die Leistung nach Bildschirmnamen, Betriebssystemversionen, App-Versionen, Geräten und Ländern aufgeschlüsselt. **Wenn Sie im Diagramm auf eine Bildschirmladezeit, eine App-Startzeit oder einen Standort-Datenpunkt klicken, wird das Diagnosefenster auf der rechten Seite geöffnet, das weitere für den Datenpunkt relevante Informationen bietet, einschließlich der letzten korrelierten Sitzungen und Links zur Registerkarte Sitzungen zur Fehlerbehebung.**

  Auf dieser Registerkarte können Sie auch zwischen **Bildschirmladevorgänge**, **App-Starts** und **Standort umschalten, um weitere Informationen zur Anwendungsleistung** zu erhalten.

  Die Registerkarte enthält auch den Wert des Anwendungsleistungsindex (Apdex), der den Grad der Zufriedenheit der Endbenutzer angibt. Die Punktzahl reicht von 0 (am wenigsten zufrieden) bis 1 (am zufriedensten). Die Ergebnisse basieren nur auf der Anwendungsleistung. Weitere Informationen über Apdex-Ergebnisse finden Sie unter [CloudWatch Wie RUM die Apdex-Ergebnisse festlegt](#CloudWatch-RUM-apdex).
+ Auf der Registerkarte **Fehler** werden Anwendungsprobleme in drei Kategorien unterteilt: Netzwerkfehler, Abstürze und ANRs (Android) /App hängt (iOS). Die Registerkarte **Netzwerkfehler** enthält ein Liniendiagramm, das die Netzwerklatenz, Client-Fehler (4xx-Statuscode) und Serverfehler (5xx-Statuscode) anzeigt. Wenn Sie auf einen Datenpunkt für eine dieser Linien im Diagramm klicken, wird das Diagnosefenster geöffnet. In der unteren Tabelle sind die 100 gängigsten Netzwerkrouten aufgeführt. Wenn Sie auf ein Optionsfeld klicken, wird das Liniendiagramm nach der ausgewählten Netzwerkroute gefiltert.

  In ähnlicher Weise zeigen die Tabs **Abstürze** und **ANRs/App hängt** eine Reihe von Linien für die Anzahl der einzelnen Fehler an, und diese können nicht behoben werden. In der unteren Tabelle werden die häufigsten Absturzmeldungen oder der am häufigsten vorkommende ANR/App Hang Stack Trace angezeigt. Wenn Sie auf ein Optionsfeld klicken, wird das Diagramm gefiltert, und wenn Sie auf die Fehlermeldung klicken, wird der vollständige Stack-Trace angezeigt.
+ Auf der Registerkarte **Sessions** wird eine Tabelle angezeigt, in der alle Sessions in absteigender chronologischer Reihenfolge aufgelistet sind. Unten zeigt eine Wasserfall-Visualisierung die gesamte Telemetriedaten für die ausgewählte Sitzung an, sodass Sie Benutzerinteraktionen verfolgen und Leistungsprobleme identifizieren können. Jede Zeile im Wasserfall kann ausgewählt werden, um das Diagnosefenster zu öffnen. Bei HTTP-Anfragen wird eine **TraceID angezeigt, die auf die Traces-Konsole** verweist.

  Für HTTP-Anfragen mit Nicht-2xx-Statuscodes, Abstürzen oder ANRs (Android) /App Hangs (iOS) enthält das Diagnosefenster einen **Exception-Tab** mit dem Stack-Trace. Über die Schaltfläche „**Ansicht**“ im Wasserfall können Sie schnell auf diese Informationen zugreifen.
+ Auf der Registerkarte „** CloudWatchMetriken**“ werden alle von Ihrem App-Monitor veröffentlichten Standardmetriken angezeigt, darunter Leistungskennzahlen (Ladezeiten auf dem Bildschirm, Startzeiten bei unterbrochener Anwendung), Fehlermetriken (Abstürze, ANRs/App Hangserrors/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, HTTP ColdLaunchTime und WarmLaunchTime. Das Dashboard zeigt drei Metrikvariationen pro Metriktyp. Da es sich um CloudWatch Metriken handelt, können Sie diesen Tab auch mit der Option Zum Dashboard **hinzufügen in Ihr eigenes Dashboard** exportieren und ihn so aktualisieren, dass er weitere Metriken enthält.
+ Die Registerkarte **Konfiguration** bietet Zugriff auf die allgemeinen Einstellungen und Konfigurationsdetails Ihres App-Monitors. Sie können auch auf die Registerkarte **Codefragmente** zugreifen, die Anweisungen zur Instrumentierung Ihrer mobilen Anwendung mit dem ADOT SDK enthält, einschließlich manueller und Zero-Code-Instrumentierungsoptionen.

### CloudWatch Wie RUM die Apdex-Ergebnisse festlegt
<a name="CloudWatch-RUM-apdex"></a>

Apdex (Application Performance Index) ist ein offener Standard, der eine Methode zum Melden, Benchmarking und Bewerten der Reaktionszeit von Anwendungen definiert. Ein Apdex-Score hilft Ihnen, die Auswirkungen auf die Anwendungsleistung im Laufe der Zeit zu verstehen und zu identifizieren.

Der Apdex-Score gibt die Zufriedenheit der Endnutzer an. Die Punktzahl reicht von 0 (am wenigsten zufrieden) bis 1 (am zufriedensten). Die Ergebnisse basieren nur auf der Anwendungsleistung. Benutzer werden nicht aufgefordert, die Anwendung zu bewerten.

Jeder einzelne Apdex-Score gehört zu einem von drei Schwellenwerten. Basierend auf dem Apdex-Schwellenwert und der tatsächlichen Reaktionszeit der Anwendung gibt es die folgenden drei Arten von Leistung:
+ **Zufrieden** — Die tatsächliche Reaktionszeit der Anwendung ist kleiner oder gleich dem Apdex-Schwellenwert. Für CloudWatch RUM liegt dieser Schwellenwert bei 2000 ms oder weniger.
+ **Tolerierbar** — Die tatsächliche Reaktionszeit der Anwendung ist höher als der Apdex-Schwellenwert, aber kleiner oder gleich dem Vierfachen des Apdex-Schwellenwerts. Für CloudWatch RUM liegt dieser Bereich zwischen 2000 und 8000 ms.
+ **Frustrierend** — Die tatsächliche Reaktionszeit der Anwendung ist mehr als das Vierfache des Apdex-Schwellenwerts. Bei CloudWatch RUM liegt dieser Bereich bei über 8000 ms.

Der gesamte Apdex-Score von 0-1 wird nach folgender Formel berechnet:

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

# CloudWatch Metriken, die Sie mit CloudWatch RUM sammeln können
<a name="CloudWatch-RUM-metrics"></a>

In den Tabellen in diesem Abschnitt sind die Metriken aufgeführt, die Sie automatisch mit CloudWatch RUM aus Webanwendungen, mobilen Anwendungen oder beidem sammeln. Sie können diese Metriken in der CloudWatch Konsole sehen. Weitere Informationen finden Sie unter [Anzeigen der verfügbaren Metriken](viewing_metrics_with_cloudwatch.md).

Sie können optional auch erweiterte Messwerte an senden CloudWatch. Weitere Informationen finden Sie unter [Erweiterte Metriken](CloudWatch-RUM-custom-and-extended-metrics.md#CloudWatch-RUM-vended-metrics).

Diese Metriken werden im Metrik-Namespace namens `AWS/RUM` veröffentlicht. Alle der folgenden Metriken werden mit einer `application_name`-Dimension veröffentlicht. Der Wert dieser Dimension ist der Name der App-Überwachung. Einige Metriken werden auch mit zusätzlichen Dimensionen veröffentlicht, wie in der folgenden Tabelle aufgeführt.


**Web-Metriken**  

| Metrik | Einheit | Description | 
| --- | --- | --- | 
|  `HttpStatusCodeCount` |  Anzahl  |  Die Anzahl der HTTP-Antworten in der Anwendung nach ihrem Antwortstatuscode. Zusätzliche Dimensionen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `Http4xxCount` |  Anzahl  |  Die Anzahl der HTTP-Antworten in der Anwendung, mit 4xx Antwortstatuscode. Diese werden auf der Grundlage von `http_event`-RUM-Ereignissen berechnet, die zu 4xx-Codes führen.  | 
|  `Http4xxCountPerSession` |  Anzahl  |  Die Anzahl der HTTP-Antworten in einer Sitzung, mit 4xx-Antwortstatuscode. Diese werden auf der Grundlage von `http_event`-RUM-Ereignissen berechnet, die zu 4xx-Codes führen.  | 
|  `Http4xxCountPerPageView` |  Anzahl  |  Die Anzahl der HTTP-Antworten in einer Seitenrezension, mit 4xx-Antwortstatuscode. Diese werden auf der Grundlage von `http_event`-RUM-Ereignissen berechnet, die zu 4xx-Codes führen.  | 
|  `Http5xxCount` |  Anzahl  |  Die Anzahl der HTTP-Antworten in der Anwendung, mit 5xx Antwortstatuscode. Diese werden auf der Grundlage von `http_event`-RUM-Ereignissen berechnet, die zu 5xx-Codes führen.  | 
|  `Http5xxCountPerSession` |  Anzahl  |  Die Anzahl der HTTP-Antworten in der Sitzung, mit 5xx Antwortstatuscode. Diese werden auf der Grundlage von `http_event`-RUM-Ereignissen berechnet, die zu 5xx-Codes führen.  | 
|  `Http5xxCountPerPageView` |  Anzahl  |  Die Anzahl der HTTP-Antworten in einer Seitenrezension, mit dem Antwortstatuscode 5xx. Diese werden auf der Grundlage von `http_event`-RUM-Ereignissen berechnet, die zu 5xx-Codes führen.  | 
|  `JsErrorCount` |  Anzahl  |  Die Anzahl der aufgenommenen JavaScript Fehlerereignisse.   | 
|  `JsErrorCountPerSession` |  Anzahl  |  Die Anzahl der in einer Sitzung aufgenommenen JavaScript Fehlerereignisse.  | 
|  `JsErrorCountPerPageView` |  Anzahl  |  Die Anzahl der bei einer Seitenüberprüfung aufgenommenen JavaScript Fehlerereignisse.  | 
|  `NavigationFrustratedTransaction` |  Anzahl  |  Die Anzahl der Navigationsereignisse mit einer `duration` über dem Frustrationsschwellwert, der 8000 ms beträgt. Die Dauer von Navigationsereignissen wird in der `PerformanceNavigationDuration`-Metrik verfolgt.  | 
|  `NavigationSatisfiedTransaction` |  Anzahl  |  Die Anzahl der Navigationsereignisse mit einer `duration`, die geringer ist als das Apdex-Ziel, das 2000 ms beträgt. Die Dauer von Navigationsereignissen wird in der `PerformanceNavigationDuration`-Metrik verfolgt.  | 
|  `NavigationToleratedTransaction` |  Anzahl  |  Die Anzahl der Navigationsereignisse mit einer `duration` zwischen 2000 ms und 8000 ms. Die Dauer von Navigationsereignissen wird in der `PerformanceNavigationDuration`-Metrik verfolgt.  | 
|  `PageViewCount` |  Anzahl  |  Die Anzahl der von der App-Überwachung aufgenommenen Seitenaufruf-Ereignisse. Dies wird durch Zählen der `page_view_event`-RUM-Ereignisse berechnet.  | 
|  `PageViewCountPerSession` |  Anzahl  |  Die Anzahl der Seitenaufruf-Ereignisse in einer Sitzung. | 
|  `PerformanceResourceDuration` |  Millisekunden  |  Die `duration` eines Ressourcenereignisses. Zusätzliche Dimensionen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html)  | 
|  `PerformanceNavigationDuration` |  Millisekunden  |  Die `duration` eines Navigationsereignisses.  | 
|  `RumEventPayloadSize` |  Bytes  |  Die Größe jedes von RUM aufgenommenen CloudWatch Ereignisses. Sie können auch die `SampleCount`-Statistik für diese Metrik verwenden, um die Anzahl der Ereignisse zu überwachen, die eine App-Überwachung erfasst.  | 
|  `SessionCount` |  Anzahl  |  Die Anzahl der vom App-Monitor aufgenommenen Sitzungsstart-Ereignisse. Mit anderen Worten: Die Anzahl der neu gestarteten Sitzungen.  | 
|  `SessionDuration` |  Millisekunden  |  Die Dauer einer Sitzung. Diese werden auf der Grundlage der Zeit zwischen dem ersten und dem letzten Ereignis in einer Sitzung berechnet.  | 
|  `TimeOnPage` |  Millisekunden  |  Die Dauer eines Seitenaufrufs. Diese werden auf der Grundlage der Zeit bis zum nächsten Seitenaufruf berechnet, mit Ausnahme der letzten Seite in einer Sitzung, bei der es sich um die Zeit zwischen dem ersten und dem letzten Ereignis auf dieser Seite handelt.  | 
|  `WebVitalsCumulativeLayoutShift` |  Keine  |  Verfolgt den Wert der kumulativen Layoutverschiebungs-Ereignisse.  | 
|  `WebVitalsFirstInputDelay` |  Millisekunden  |  Verfolgt den Wert der ersten Eingabeverzögerungs-Ereignisse.  | 
|  `WebVitalsLargestContentfulPaint` |  Millisekunden  |  Verfolgt den Wert der größten inhaltlichen Paint-Ereignisse.  | 
|  `WebVitalsInteractionToNextPaint` |  Millisekunden  |  Verfolgt den Wert der Interaktion bis zu den nächsten Zeichnungsereignissen.  | 

Sie können erweiterte Messwerte für Ihre mobile Anwendung konfigurieren, um zusätzliche Analysedimensionen bereitzustellen.


**Messwerte für mobile Geräte**  

| Metrik | Einheit | Description | 
| --- | --- | --- | 
|  `ANRCount`  |  Anzahl  |  Nur für Android: Die Anzahl der Fälle, in denen die Anwendung nicht reagiert (ANR), die auftreten, wenn die Anwendung länger als 5 Sekunden nicht reagiert, was zu einem Absturz der Anwendung führt.  | 
|  `AppHangCount`  |  Anzahl  |  Nur für iOS: Die Häufigkeit, mit der die Anwendung in der Hauptschleife länger als 250 ms nicht mehr reagiert hat.  | 
|  `ColdAppLaunchFrustratedTransaction`  |  Anzahl  |  Die Anzahl der Kaltstarts von Apps, deren Abschluss länger als 8 Sekunden dauerte, was wahrscheinlich zu Frustration bei den Benutzern geführt hat.  | 
|  `ColdAppLaunchSatisfiedTransaction`  |  Anzahl  |  Die Anzahl der Cold-App-Starts, die in weniger als 2 Sekunden abgeschlossen wurden und für eine zufriedenstellende Benutzererfahrung gesorgt haben.  | 
|  `ColdAppLaunchToleratedTransaction`  |  Anzahl  |  Die Anzahl der Cold-App-Starts, die zwischen 2 und 8 Sekunden abgeschlossen wurden und für eine erträgliche, aber nicht ideale Benutzererfahrung sorgen.  | 
|  `ColdLaunchTime`  |  Millisekunden  |  Zeit, die benötigt wurde, um die Anwendung aus einem beendeten Zustand heraus zu starten. Für Android: Zeit von der Anwendung `onCreate` bis zum Abschluss der ersten Aktivität. Für iOS: Zeit vom Start der Anwendung (bestimmt durch den Befehl zum `sysctl` Prozessstart) bis`didBecomeActiveNotification`.  | 
|  `CrashCount`  |  Anzahl  |  Die Anzahl unerwarteter Programmabbrüche, die durch unbehandelte Ausnahmen oder die Beendigung des Betriebssystems verursacht wurden. Für Android: Stürzt aufgrund von unbehandelten Ausnahmen oder Systemabbrüchen ab. Für iOS: Abstürze aufgrund nicht behandelter Ausnahmen, schwerwiegender Fehler oder Systemabbruch. Absturzdaten werden lokal gespeichert und beim nächsten Start der App gemeldet.  | 
|  `DroppedEventsCount`  |  Anzahl  |  Die Anzahl der Protokollereignisse, die gelöscht wurden, weil sie die maximale Größenbeschränkung von 30 KB pro Ereignis überschritten haben.  | 
|  `DroppedSpansCount`  |  Anzahl  |  Die Anzahl der Spans, die gelöscht wurden, weil sie die maximale Größenbeschränkung von 30 KB pro Bereich überschritten haben.  | 
|  `Http4xxCount`  |  Anzahl  |  Zeichnet die Anzahl der HTTP-Clientfehler auf, auf die Web- oder Mobilanwendung bei HTTP-Anfragen gestoßen sind.  | 
|  `Http5xxCount`  |  Anzahl  |  Zeichnet die Anzahl der HTTP-Serverfehler auf, auf die Web- oder Mobilanwendung bei HTTP-Anfragen gestoßen ist.  | 
|  `LogPayloadSize`  |  Bytes  |  Die Größe der Protokolltelemetriedaten, die an CloudWatch RUM gesendet werden, in Byte. Sie können die `SampleCount` Statistik für diese Metrik auch verwenden, um die Anzahl der Protokollereignisse zu überwachen, die ein App-Monitor aufnimmt.  | 
|  `NetworkLatency`  |  Millisekunden  |  Die Zeit, die benötigt wird, bis Netzwerkanfragen abgeschlossen sind, wobei die Round-Trip-Zeit von der Initiierung der Anfrage bis zum Abschluss der Antwort gemessen wird.  | 
|  `ScreenLoadCount`  |  Anzahl  |  Die Gesamtzahl der Bildschirmladevorgänge.  | 
|  `ScreenLoadToleratedTransaction`  |  Anzahl  |  Die Anzahl der Bildschirmladevorgänge, die zwischen 2 und 8 Sekunden abgeschlossen wurden, was für eine erträgliche, aber nicht ideale Benutzererfahrung sorgt.  | 
|  `SessionCount`  |  Anzahl  |  Die Gesamtzahl der eindeutigen Benutzersitzungen mit der Anwendung. Eine Sitzung beginnt, wenn der Benutzer die App öffnet, und endet nach 30 Minuten Inaktivität oder wenn sie ausdrücklich beendet wird.  | 
|  `SpanPayloadSize`  |  Bytes  |  Die Größe der Span-Telemetriedaten in Byte, die an CloudWatch RUM gesendet werden. Sie können die `SampleCount` Statistik für diese Metrik auch verwenden, um die Anzahl der Spans zu überwachen, die ein App-Monitor aufnimmt.  | 
|  `WarmAppLaunchFrustratedTransaction`  |  Anzahl  |  Die Anzahl der Schnellstarts von Apps, deren Abschluss länger als 8 Sekunden gedauert hat, was wahrscheinlich zu Frustration bei den Benutzern geführt hat.  | 
|  `WarmAppLaunchSatisfiedTransaction`  |  Anzahl  |  Die Anzahl der warmen App-Starts, die in weniger als 2 Sekunden abgeschlossen wurden und für eine zufriedenstellende Benutzererfahrung gesorgt haben.  | 
|  `WarmAppLaunchToleratedTransaction`  |  Anzahl  |  Die Anzahl der warmen App-Starts, die zwischen 2 und 8 Sekunden abgeschlossen wurden und für eine erträgliche, aber nicht ideale Benutzererfahrung sorgen.  | 
|  `WarmLaunchTime`  |  Millisekunden  |  Zeit, die benötigt wurde, um die Anwendung aus dem Hintergrundstatus heraus zu starten. Für Android: Zeit von der Anwendung `onCreate` bis zum Abschluss der ersten Aktivität. Für iOS: Zeit von `UIApplicationWillEnterForegroundNotification` bis`didBecomeActiveNotification`.  | 

# Benutzerdefinierte Metriken und erweiterte Messwerte, an die Sie senden können CloudWatch
<a name="CloudWatch-RUM-custom-and-extended-metrics"></a>

Standardmäßig senden RUM-App-Monitore Metriken an. CloudWatch Diese Standardmetriken und -dimensionen sind in [CloudWatch Metriken aufgeführt, die Sie mit CloudWatch RUM sammeln können](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-metrics.html).

Sie können auch eine App-Überwachung einrichten, um Metriken zu exportieren. Die App-Überwachung kann erweiterte Metriken, benutzerdefinierte Metriken oder beides senden. Es kann sie an senden CloudWatch.
+ **Benutzerdefinierte Metriken** — Benutzerdefinierte Metriken sind Metriken, die Sie definieren. Bei benutzerdefinierten Metriken können Sie einen beliebigen Metriknamen und Namespace verwenden. Um die Metriken zu erhalten, können Sie beliebige benutzerdefinierte Ereignisse, integrierte Ereignisse, benutzerdefinierte Attribute oder Standardattribute verwenden.

  Sie können benutzerdefinierte Metriken an senden CloudWatch.
+ **Erweiterte Metriken** — Sie können jede der CloudWatch Standard-RUM-Metriken CloudWatch mit zusätzlichen Dimensionen an senden. Auf diese Weise können diese Metriken Ihnen einen detaillierteren Überblick verschaffen.

**Topics**
+ [Benutzerdefinierte Metriken](#CloudWatch-RUM-custom-metrics)
+ [Erweiterte Metriken](#CloudWatch-RUM-vended-metrics)

## Benutzerdefinierte Metriken
<a name="CloudWatch-RUM-custom-metrics"></a>

Um benutzerdefinierte Metriken zu senden, müssen Sie die AWS APIs oder AWS CLI anstelle der Konsole verwenden. Weitere Informationen zur Verwendung von finden Sie unter [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html)und [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html). AWS APIs

Die maximale Anzahl von erweiterten und benutzerdefinierten Metrikdefinitionen, die ein Ziel enthalten kann, beträgt 2 000. Für jede benutzerdefinierte Metrik oder erweiterte Metrik, die Sie an jedes Ziel senden, zählt jede Kombination aus Dimensionsname und Dimensionswert für dieses Limit. Für benutzerdefinierte Messwerte, die aus Ereignissen oder Attributen von CloudWatch RUM abgeleitet wurden, fallen keine Gebühren an.

Das folgende Beispiel zeigt, wie Sie eine benutzerdefinierte Metrik erstellen, die von einem benutzerdefinierten Ereignis abgeleitet ist. Hier das Beispiel für das verwendete benutzerdefinierte Ereignis:

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

Mit diesem benutzerdefinierten Ereignis können Sie eine benutzerdefinierte Metrik erstellen, die die Anzahl der Besuche auf der URL `amazonaws.com` von Chrome-Browsern aus zählt. Die folgende Definition erstellt eine Metrik namens `AmazonVisitsCount` in Ihrem Konto im `RUM/CustomMetrics/PageVisits`-Namespace.

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

## Erweiterte Metriken
<a name="CloudWatch-RUM-vended-metrics"></a>

Wenn Sie erweiterte Metriken einrichten, können Sie jede der CloudWatch Standard-RUM-Metriken CloudWatch mit zusätzlichen Dimensionen an senden, sodass Sie anhand der Metriken einen detaillierteren Überblick erhalten.

Weitere Informationen zu den CloudWatch Standard-RUM-Metriken finden Sie unter. [CloudWatch Metriken, die Sie mit CloudWatch RUM sammeln können](CloudWatch-RUM-metrics.md)

Die maximale Anzahl von erweiterten und benutzerdefinierten Metrikdefinitionen, die ein Ziel enthalten kann, beträgt 2 000. Für jede erweiterte oder benutzerdefinierte Metrik, die Sie an jedes Ziel senden, zählt jede Kombination aus Dimensionsname und Dimensionswert als eine erweiterte Metrik für dieses Limit.

Wenn Sie erweiterte Messwerte an senden CloudWatch, können Sie die CloudWatch RUM-Konsole verwenden, um CloudWatch Alarme für sie zu erstellen.

Erweiterte Metriken, die für die Standardmetriken von CloudWatch RUM erstellt wurden, werden Ihnen nicht in Rechnung gestellt.

### Erweiterte Metriken für Webanwendungen
<a name="CloudWatch-RUM-web-extended-metrics"></a>

Die folgenden Dimensionen werden für erweiterte Metriken für Webanwendungen unterstützt:
+ `BrowserName`

  Beispiel für Dimensionswerte: `Chrome`, `Firefox`, `Chrome Headless`
+ `CountryCode` Dabei wird das ISO-3166-Format mit zweibuchstabigen Codes verwendet.

  Beispiel für Dimensionswerte: `US`, `JP`, `DE`
+ `DeviceType`

  Beispiel für Dimensionswerte: `desktop`, `mobile`, `tablet`, `embedded`
+ `FileType`

  Beispiel für Dimensionswerte: `Image`, `Stylesheet`
+ `OSName`

  Beispiel für Dimensionswerte: `Linux`, `Windows`, `iOS`, `Android`
+ `PageId`

### Erweiterte Metriken für mobile Anwendungen
<a name="CloudWatch-RUM-mobile-extended-metrics"></a>

Die folgenden Dimensionen werden für erweiterte Metriken für mobile Anwendungen unterstützt:
+ `ScreenName`
  + Wert aus dem Bildschirmnamenattribut `attributes.screen.name` Ihrer Anwendung
  + Beispielwerte: HomeScreen, SettingsView, ProfilePage
+ `DeviceModel`
  + Wert aus dem Gerätemodellattribut - `resource.attributes.device.model.name`
  + Beispielwerte: iPhone14,3, SM-G998B
+ `OSVersion`
  + Wert aus dem Versionsattribut des Betriebssystems - `resource.attributes.os.version`
  + Beispielwerte: 16.0, 13.0

**Anmerkung**  
Derzeit unterstützte Standardmetriken für mobile Anwendungen:`ScreenLoadTime`,`ScreenLoadCount`,`NetworkLatency`,`Http4xxCount`,,`Http5xxCount`,`CrashCount`,`ANRCount`,`AppHangCount`,`ColdLaunchTime`, `WarmLaunchTime``SessionCount`, `SpanPayloadSize` und. `LogPayloadSize`

### Erweiterte Metriken über die Konsole einrichten
<a name="CloudWatch-RUM-extended-metrics-console"></a>

Gehen Sie wie folgt vor, um die Konsole zum Senden erweiterter Messwerte zu CloudWatch verwenden.

Informationen zur Verwendung von AWS APIs , um erweiterte Messwerte an beide zu senden CloudWatch, finden Sie unter [PutRumMetricsDestination](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_PutRumMetricsDestination.html)und [BatchCreateRumMetricDefinitions](https://docs.aws.amazon.com/cloudwatchrum/latest/APIReference/API_BatchCreateRumMetricDefinitions.html).

**So richten Sie mit der Konsole einen App-Monitor ein und senden erweiterte RUM-Metriken an CloudWatch**

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie den Namen des App-Monitors, der die Metriken senden soll.

1. Wählen Sie den Tab **Configuration** (Konfiguration) und wählen Sie dann **RUM extended metrics** (erweiterte RUM-Metriken) aus.

1. Wählen Sie **Send metrics** (Metriken senden) aus.

1. Wählen Sie einen oder mehrere Metriknamen aus, um sie mit zusätzlichen Dimensionen zu senden.

1. Wählen Sie einen oder mehrere Faktoren aus, die als Dimensionen für diese Metriken verwendet werden sollen. Während Sie Ihre Auswahl treffen, wird die Anzahl der erweiterten Metriken, die durch Ihre Auswahl erstellt wurden, unter **Number of extended metrics** (Anzahl der erweiterten Metriken) angezeigt.

   Diese Zahl wird berechnet, indem die Anzahl der ausgewählten Metriknamen mit der Anzahl der verschiedenen Dimensionen, die Sie erstellen, multipliziert wird.

   1. Um eine Metrik mit Seiten-ID als Dimension zu senden, wählen Sie **Nach Seiten-ID suchen** und wählen Sie dann die Seite aus, die Sie verwenden IDs möchten.

   1. Um eine Metrik mit dem Gerätetyp als Dimension zu senden, wählen Sie entweder **Desktop devices** (Desktop-Geräte) oder **Mobile and tablets** (Mobil und Tablets) aus.

   1. Um eine Metrik mit dem Betriebssystem als Dimension zu senden, wählen Sie unter **Operating system** (Betriebssystem) ein oder mehrere Betriebssysteme aus.

   1. Um eine Metrik mit dem Browsertyp als Dimension zu senden, wählen Sie unter Browser einen oder mehrere **Browsers** (Browser) aus.

   1. Um eine Metrik mit Geolokalisierung als Dimension zu senden, wählen Sie unter Standorte einen oder mehrere **Locations** (Standorte) aus.

      Nur die Standorte, von denen dieser Anwendungsmonitor Messwerte gemeldet hat, werden in der Liste angezeigt, aus denen Sie auswählen können.

1. Wenn Sie mit Ihrer Auswahl fertig sind, wählen Sie **Send metrics** (Metriken senden) aus.

1. (Optional) Um einen Alarm zu erstellen, der eine der Metriken überwacht, wählen Sie in der Liste der **Extended metrics** (erweiterte Metriken) in der Zeile dieser Metrik die Option **Create alarm** (Alarm erstellen) aus.

   Allgemeine Informationen zu CloudWatch Alarmen finden Sie unter[CloudWatch Amazon-Alarme verwenden](CloudWatch_Alarms.md). Eine Anleitung zum Einstellen eines Alarms für eine erweiterte CloudWatch RUM-Metrik finden Sie unter[Tutorial: Eine erweiterte Metrik erstellen und sie alarmieren](#CloudWatch-RUM-extended-metrics-alarmtutorial).

**Das Senden erweiterter Metriken beenden**

**So verwenden Sie die Konsole, um das Senden erweiterter Metriken zu beenden**

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie den Namen des App-Monitors, der die Metriken senden soll.

1. Wählen Sie den Tab **Configuration** (Konfiguration) und wählen Sie dann **RUM extended metrics** (erweiterte RUM-Metriken) aus.

1. Wählen Sie eine oder mehrere Kombinationen aus Metriknamen und Dimensionen aus, um das Senden zu beenden. Wählen Sie dann **Actions** (Aktionen), **Delete** (Löschen).

### Tutorial: Eine erweiterte Metrik erstellen und sie alarmieren
<a name="CloudWatch-RUM-extended-metrics-alarmtutorial"></a>

Dieses Tutorial zeigt, wie Sie eine erweiterte Metrik einrichten, an die gesendet werden soll CloudWatch, und dann, wie Sie einen Alarm für diese Metrik einrichten. In diesem Tutorial erstellen Sie eine Metrik, die JavaScript Fehler im Chrome-Browser verfolgt.

**So richten Sie diese erweiterte Metrik ein und stellen einen Alarm dafür ein**

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie den Namen des App-Monitors, der die Metrik senden soll.

1. Wählen Sie den Tab **Configuration** (Konfiguration) und wählen Sie dann **RUM extended metrics** (erweiterte RUM-Metriken) aus.

1. Wählen Sie **Send metrics** (Metriken senden) aus.

1. Wählen Sie **JSErrorAnzahl** aus.

1. Wählen Sie unter **Browsers** (Browser) **Chrome** (Chrome) aus.

   Diese Kombination aus **JSErrorCount** und **Chrome** sendet eine erweiterte Metrik an CloudWatch. Die Metrik zählt JavaScript Fehler nur für Benutzersitzungen, die den Chrome-Browser verwenden. Der Metrikname **JsErrorCount**und der Name der Dimension lauten **Browser**.

1. Wählen Sie **Send metrics** (Metriken senden) aus.

1. Wählen Sie in der Liste der **erweiterten Messwerte** in der Zeile, die **JsErrorCount**unter **Name** und **Chrome** unter angezeigt wird, die Option **Alarm erstellen** aus **BrowserName**.

1. Vergewissern Sie sich unter **Metrik und Bedingungen angeben**, dass der **Metrikname** und die **BrowserName**Felder vorab mit den richtigen Werten gefüllt sind.

1. Wählen Sie unter **Statistic** (Statistik) die Statistik aus, die Sie für den Alarm verwenden möchten. Der **Average** (Durchschnitt) ist eine gute Wahl für diese Art von Zählmetrik.

1. Wählen Sie unter **Zeitraum** die Option **5 Minuten** aus.

1. Führen Sie unter **Bedingungen** die folgenden Schritte aus:
   + Wählen Sie **Static** (Statisch).
   + Wählen Sie **Greater** (Größer), um festzulegen, dass der Alarm in den Zustand ALARM wechseln soll, wenn die Anzahl der Fehler den Schwellenwert überschreitet, den Sie gerade angeben möchten.
   + Unter **than ...** (als ...), geben Sie die Zahl für den Alarmschwellenwert ein. Der Alarm geht in den Zustand ALARM über, wenn die Anzahl der Fehler über einen Zeitraum von 5 Minuten diesen Wert überschreitet.

1. (Optional) Standardmäßig wechselt der Alarm in den Zustand ALARM, sobald die Anzahl der Fehler den von Ihnen festgelegten Schwellenwert innerhalb eines Zeitraums von 5 Minuten überschreitet. Sie können dies optional ändern, sodass der Alarm nur dann in den Zustand ALARM wechselt, wenn diese Zahl für mehr als einen Zeitraum von 5 Minuten überschritten wird.

   Wählen Sie dazu **Additional configuration** (Zusätzliche Konfiguration) und geben Sie dann für **Datapoints to alarm** (zu alarmierende Datenpunkte) an, wie viele 5-Minuten-Zeiträume die Fehlernummer über dem Schwellenwert liegen muss, um den Alarm auszulösen. Sie können beispielsweise 2 von 2 auswählen, damit der Alarm nur ausgelöst wird, wenn zwei aufeinanderfolgende 5-Minuten-Zeiträume den Schwellenwert überschreiten, oder 2 von 3, um den Alarm auszulösen, wenn zwei von drei aufeinanderfolgenden 5-Minuten-Zeiträumen den Schwellenwert überschreiten. 

   Weitere Informationen zu den verschiedenen Arten der Alarmauswertung finden Sie unter [Auswertung von Alarmen](alarm-evaluation.md).

1. Wählen Sie **Weiter** aus.

1. Geben Sie unter **Configure actions** (Aktionen konfigurieren) an, was passieren soll, wenn der Alarm in den Alarmzustand wechselt. Führen Sie Folgendes aus, um eine Benachrichtigung mit Amazon SNS zu erhalten:
   + Wählen Sie **Add notification (Benachrichtigung hinzufügen)** aus.
   + Wählen Sie **In Alarm** aus.
   + Wählen Sie ein vorhandenes SNS-Thema aus oder erstellen Sie ein neues Thema. Wenn Sie eine neue erstellen, geben Sie einen Namen für sie an und fügen Sie mindestens eine E-Mail-Adresse hinzu.

1. Wählen Sie **Weiter** aus.

1. Geben Sie einen Namen und optional eine Beschreibung für den Alarm ein und wählen Sie dann **Next** (Weiter).

1. Prüfen Sie die Details und wählen Sie **Create alarm** (Alarm erstellen).

# Datenschutz und Datenschutz bei RUM CloudWatch
<a name="CloudWatch-RUM-privacy"></a>

Das [Modell der AWS gemeinsamen Verantwortung](https://aws.amazon.com/compliance/shared-responsibility-model/) gilt für den Datenschutz und den Datenschutz in Amazon CloudWatch RUM. AWS Ist, wie in diesem Modell beschrieben, für den Schutz der globalen Infrastruktur verantwortlich, auf der die gesamte AWS Cloud läuft. Sie sind dafür verantwortlich, die Kontrolle über Ihre in dieser Infrastruktur gehosteten Inhalte zu behalten. Weitere Informationen zum Datenschutz finden Sie unter [Häufig gestellte Fragen zum Datenschutz](https://aws.amazon.com/compliance/data-privacy-faq/). Informationen zum Datenschutz in Europa finden Sie im Blogbeitrag [The AWS Shared Responsibility Model und GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) im AWS Security Blog. Weitere Ressourcen zur Einhaltung der DSGVO-Anforderungen finden Sie im [Center für Datenschutz-Grundverordnung (DSGVO)](https://aws.amazon.com/compliance/gdpr-center/).

Amazon CloudWatch RUM generiert auf der Grundlage Ihrer Eingabe von Endbenutzerdaten, die Sie sammeln möchten, einen Codeausschnitt, den Sie in Ihren Website- oder Webanwendungscode einbetten können. Der Webclient, der durch den Codeausschnitt heruntergeladen und konfiguriert wurde, verwendet Cookies (oder ähnliche Technologien), um Ihnen bei der Erfassung von Endbenutzerdaten zu helfen. Die Verwendung von Cookies (oder ähnlichen Technologien) unterliegt in bestimmten Gerichtsbarkeiten den Datenschutzbestimmungen. Bevor Sie Amazon CloudWatch RUM verwenden, empfehlen wir Ihnen dringend, Ihre Verpflichtungen zur Einhaltung der geltenden Gesetze zu überprüfen, einschließlich aller geltenden rechtlichen Anforderungen, um rechtlich angemessene Datenschutzhinweise bereitzustellen und alle erforderlichen Einwilligungen für die Verwendung von Cookies und die Verarbeitung (einschließlich Erfassung) von Endnutzerdaten einzuholen. Weitere Informationen darüber, wie der Webclient Cookies (oder ähnliche Technologien) verwendet und welche Endbenutzerdaten der Webclient sammelt, finden Sie unter [Vom CloudWatch RUM-Webclient gesammelte Informationen](CloudWatch-RUM-datacollected.md) und [CloudWatch RUM-Webclient-Cookies (oder ähnliche Technologien)](#CloudWatch-RUM-cookies).

Wir empfehlen dringend, in Freitextfeldern keine sensiblen personenbezogenen Daten wie Kontonummern von Endkunden, E-Mail-Adressen oder sonstige personenbezogenen Daten einzugeben. Alle Daten, die Sie in Amazon CloudWatch RUM oder andere Dienste eingeben, können in Diagnoseprotokollen enthalten sein. 



## CloudWatch RUM-Webclient-Cookies (oder ähnliche Technologien)
<a name="CloudWatch-RUM-cookies"></a>

Der CloudWatch RUM-Webclient sammelt standardmäßig bestimmte Daten über Benutzersitzungen. Sie können Cookies aktivieren, damit der Webclient eine Benutzer-ID und eine Sitzungs-ID erfasst, die bei Seitenladevorgängen bestehen bleiben. Die Benutzer-ID wird nach dem Zufallsprinzip von RUM generiert.

Wenn diese Cookies aktiviert sind, kann RUM die folgenden Datentypen anzeigen, wenn Sie das RUM-Dashboard für diese App-Überwachung anzeigen.
+ Aggregierte Daten, die auf dem Benutzer basieren IDs, z. B. die Anzahl der einzelnen Benutzer und die Anzahl der verschiedenen Benutzer, bei denen ein Fehler aufgetreten ist. 
+ Auf der Sitzung basierende aggregierte Daten IDs, z. B. die Anzahl der Sitzungen und die Anzahl der Sitzungen, bei denen ein Fehler aufgetreten ist. 
+ Die *User Journey* (Benutzer-Journey) bezieht sich auf die Reihenfolge der Seiten, die jede ausgewählte Benutzersitzung enthält. 

**Wichtig**  
Wenn Sie diese Cookies (oder ähnliche Technologien) nicht aktivieren, zeichnet der Webclient dennoch bestimmte Informationen über Endbenutzersitzungen auftype/version, operating system type/version, z. B. Browser, Gerätetyp usw. Diese werden gesammelt, um aggregierte seitenspezifische Erkenntnisse wie Webdaten, Seitenaufrufe und Seiten mit Fehlern darzustellen. Weitere Informationen zu den aufgezeichneten Daten finden Sie unter [Vom CloudWatch RUM-Webclient gesammelte Informationen](CloudWatch-RUM-datacollected.md).

# Vom CloudWatch RUM-Webclient gesammelte Informationen
<a name="CloudWatch-RUM-datacollected"></a>

In diesem Abschnitt wird das **PutRumEvents**Schema dokumentiert, das die Struktur der Daten definiert, die Sie in Benutzersitzungen mit CloudWatch RUM sammeln können.

Eine **PutRumEvents**Anfrage sendet eine Datenstruktur mit den folgenden Feldern an CloudWatch RUM.
+ Die ID dieser RUM-Ereignisse
+ Details zur App-Überwachung mit folgendem Inhalt:
  + App-Überwachungs-ID
  + Überwachte Anwendungsversion
+ Details zur Benutzern mit folgendem Inhalt:** Dies wird nur erfasst, wenn bei der App-Überwachung Cookies aktiviert sind.**
  + Eine vom Webclient generierte Benutzer-ID
  + Sitzungs-ID
+ Das Array von [RUM-Ereignissen](#CloudWatch-RUM-datacollected-event) in diesem Batch.

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

Die Struktur jedes RUM-Ereignisses umfasst die folgenden Felder.
+ Die Ereignis-ID
+ Einen Zeitstempel
+ Einen Ereignistyp
+ Den Benutzer-Agent
+ [Metadaten](#CloudWatch-RUM-datacollected-metadata)
+ [Details zu RUM-Ereignissen](#CloudWatch-RUM-datacollected-eventDetails)

## RUM-Ereignismetadaten
<a name="CloudWatch-RUM-datacollected-metadata"></a>

Die Metadaten umfassen Seitenmetadaten, Metadaten des Benutzeragenten, Geolokalisierungs-Metadaten und Domain-Metadaten.

### Seiten-Metadaten
<a name="CloudWatch-RUM-datacollected-metadata-page"></a>

Die Seiten-Metadaten enthalten Folgendes:
+ Seiten-ID
+ Seitentitel
+ ID der übergeordneten Seite. – **Dies wird nur erfasst, wenn bei der App-Überwachung Cookies aktiviert sind.**
+ Interaktionstiefe – **Dies wird nur erfasst, wenn bei der App-Überwachung Cookies aktiviert sind**.
+ Seiten-Tags – Sie können den Seitenereignissen Tags hinzufügen, um Seiten zu gruppieren. Weitere Informationen finden Sie unter [Verwenden von Seitengruppen](CloudWatch-RUM-page-groups.md).

### Benutzer-Agent-Metadaten
<a name="CloudWatch-RUM-datacollected-metadata-useragent"></a>

Die Benutzer-Metadaten enthalten Folgendes:
+ Browser-Sprache
+ Browsername
+ Browserversion
+ Name des Betriebssystems
+ Version des Betriebssystems
+ Gerätetyp
+ Plattformtype

### Geolocation-Metadaten
<a name="CloudWatch-RUM-datacollected-metadata-geolocation"></a>

Die Geolocation-Metadaten enthalten Folgendes:
+ Ländercode
+ Unterteilungscode

### Domain-Metadaten
<a name="CloudWatch-RUM-datacollected-metadata-domain"></a>

Die Domain-Metadaten enthalten die URL-Domain.

## Details zu RUM-Ereignissen
<a name="CloudWatch-RUM-datacollected-eventDetails"></a>

Die Details eines Ereignisses folgen je nach Ereignistyp einem der folgenden Arten von Schemas.

### Sitzungsstart-Ereignis
<a name="CloudWatch-RUM-datacollected-sessionstart"></a>

Dieses Ereignis enthält keine Felder. **Dies wird nur erfasst, wenn bei der App-Überwachung Cookies aktiviert sind.**

### Seitenansicht-Schema
<a name="CloudWatch-RUM-datacollected-pageview"></a>

Ein **Seitenansicht**-Ereignis enthält die folgenden Eigenschaften: Sie können die Sammlung von Seitenansichten deaktivieren, indem Sie den Webclient konfigurieren. Weitere Informationen finden Sie in der [ CloudWatch RUM-Webclient-Dokumentation](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Name | Typ | Description | 
| --- | --- | --- | 
|  **Seiten-ID** |  Zeichenfolge  |  Eine ID, die diese Seite innerhalb der Anwendung eindeutig darstellt. Standardmäßig ist dies der URL-Pfad.  | 
|  **ID der übergeordneten Seite** |  Zeichenfolge  |  Die ID der Seite, auf der sich der Benutzer befand, als er zur aktuellen Seite navigierte. **Dies wird nur erfasst, wenn bei der App-Überwachung Cookies aktiviert sind.**   | 
|  **Interaktionstiefe** |  Zeichenfolge  |  **Dies wird nur erfasst, wenn bei der App-Überwachung Cookies aktiviert sind.**   | 

### JavaScript Fehlerschema
<a name="CloudWatch-RUM-datacollected-JavaScriptError"></a>

JavaScript Vom Agenten generierte Fehlerereignisse enthalten die folgenden Eigenschaften. Der Webclient sammelt diese Ereignisse nur, wenn Sie sich entschieden haben, die Fehlertelemetrie zu sammeln.


| Name | Typ | Description | 
| --- | --- | --- | 
|  **Fehlertyp** |  Zeichenfolge  |  Der Name des Fehlers, sofern vorhanden. Weitere Informationen finden Sie unter [error.prototype.name](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name). Einige Browser unterstützen möglicherweise keine Fehlertypen.  | 
|  **Fehlermeldung** |  Zeichenfolge  |  Die Fehlermeldung. Weitere Informationen finden Sie unter [Error.prototype.message](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message). Wenn das Fehlerfeld nicht vorhanden ist, ist dies die Meldung des Fehlerereignisses. Weitere Informationen finden Sie unter [ErrorEvent](https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent).  Fehlermeldungen sind möglicherweise in verschiedenen Browsern nicht konsistent.  | 
|  **Stack-Ablaufverfolgung** |  Zeichenfolge  |  Die Stack-Ablaufverfolgung des Fehlers wurde, falls vorhanden, auf 150 Zeichen gekürzt. Weitere Informationen finden Sie unter [Error.prototype.Stack](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack).  Einige Browser unterstützen möglicherweise keine Stack-Ablaufverfolgungen.  | 

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

Vom Agent generierte Ereignisse des Document Object Model (DOM) enthalten die folgenden Eigenschaften. Diese Ereignisse werden standardmäßig nicht erfasst. Sie werden nur gesammelt, wenn Sie die Interaktionstelemetrie aktivieren. Weitere Informationen finden Sie in der [ CloudWatch RUM-Webclient-Dokumentation](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).


| Name | Typ | Description | 
| --- | --- | --- | 
|  **Veranstaltung** |  Zeichenfolge  |  Der Typ des DOM-Ereignisses wie Klicken, Scrollen oder Hover. Weitere Informationen finden Sie unter [Ereignisreferenz](https://developer.mozilla.org/en-US/docs/Web/Events).  | 
|  **Element** |  Zeichenfolge  |  Der DOM-Elementtyp  | 
|  **Element-ID** |  Zeichenfolge  |  Wenn das Element, das das Ereignis generiert hat, eine ID besitzt, speichert diese Eigenschaft diese ID. Weitere Informationen finden Sie unter [Element.id](https://developer.mozilla.org/en-US/docs/Web/API/Element/id).  | 
|  **CSSLocator** |  Zeichenfolge  |  Der CSS-Locator, der zur Identifizierung des DOM-Elements verwendet wird.  | 
|  **InteractionId** |  Zeichenfolge  |  Eine eindeutige ID für die Interaktion zwischen dem Benutzer und der Benutzeroberfläche.  | 

### Navigationsereignisschema
<a name="CloudWatch-RUM-datacollected-NavigationEvent"></a>

Navigationsereignisse werden nur erfasst, wenn die App-Überwachung die Leistungstelemetrie aktiviert hat.

Navigationsereignisse verwenden das [Navigations-Timing Level 1](https://www.w3.org/TR/navigation-timing/#performancetiming) und das [Navigations-Timing Level APIs 2.](https://w3c.github.io/navigation-timing) Stufe 2 APIs wird nicht in allen Browsern unterstützt, daher sind diese neueren Felder optional.

**Anmerkung**  
Die Timestamp-Metriken basieren auf [DOMHighResTimestamp](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp). Bei Stufe 2 APIs beziehen sich alle Zeitangaben standardmäßig auf die. `startTime` Aber für Stufe 1 wird die `navigationStart`-Metrik von Zeitstempelmetriken subtrahiert, um relative Werte zu erhalten. Alle Zeitstempelwerte sind in Millisekunden.

Navigationsereignisse enthalten die folgenden Eigenschaften.


| Name | Typ | Description | Hinweise | 
| --- | --- | --- | --- | 
|  **initiatorType** |  Zeichenfolge  |  Repräsentiert den Ressourcentyp, der das Leistungsereignis ausgelöst hat.  |  **Wert:** „Navigation“ **Stufe 1** „Navigation“ **Stufe 2** entryData.initiatorType | 
|  **navigationType** |  Zeichenfolge  |  Repräsentiert den Typ der Navigation. Dieses Attribut ist nicht erforderlich. |  **Wert:** Dieser Wert muss einer der folgenden sein: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html) | 
|  **startTime** |  Zahl  |  Gibt an, wann das Ereignis ausgelöst wird.  |  **Wert:** 0 **Stufe 1:** entryData.navigationStart – entryData.navigationStart  **Stufe 2:** entryData.startTime | 
|  **unloadEventStart** |  Zahl  |  Gibt den Zeitpunkt an, zu dem das vorherige Dokument im Fenster entladen wurde, nachdem das `unload`-Ereignis ausgegeben wurde.  |  **Wert:** Wenn kein vorheriges Dokument vorhanden ist oder wenn das vorherige Dokument oder eine der erforderlichen Weiterleitungen nicht denselben Ursprung haben, wird der Wert 0 zurückgegeben. **Stufe 1:** <pre>entryData.unloadEventStart > 0<br />  ? entryData.unloadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Ebene 2: EntryData**. unloadEventStart | 
|  **promptForUnload** |  Zahl  |  Die Zeit, die zum Entladen des Dokuments benötigt wird. Mit anderen Worten, die Zeit zwischen `unloadEventStart` und `unloadEventEnd`. `UnloadEventEnd` repräsentiert den Moment in Millisekunden, in dem der Entlade-Ereignishandler beendet ist.  |  **Wert:** Wenn kein vorheriges Dokument vorhanden ist oder wenn das vorherige Dokument oder eine der erforderlichen Weiterleitungen nicht denselben Ursprung haben, wird der Wert 0 zurückgegeben. **Ebene 1:** EntryData. unloadEventEnd - Eingabedaten. unloadEventStart **Stufe 2:** EntryData. unloadEventEnd - Eingabedaten. unloadEventStart | 
|  **redirectCount** |  Zahl  |  Eine Zahl, die die Anzahl der Weiterleitungen seit der letzten Navigation ohne Weiterleitung im aktuellen Browser-Kontext darstellt.  Dieses Attribut ist nicht erforderlich. |  **Wert:** Wenn es keine Weiterleitung gibt oder wenn es eine Weiterleitung gibt, die nicht den gleichen Ursprung wie das Zieldokument hat, ist der zurückgegebene Wert 0. **Stufe 1:** Nicht verfügbar **Stufe 2:** entryData.redirectCount | 
|  **redirectStart** |  Zahl  |  Der Zeitpunkt, zu dem die erste HTTP-Weiterleitung gestartet wird.   |  **Wert:** Wenn es keine Weiterleitung gibt oder wenn es eine Weiterleitung gibt, die nicht den gleichen Ursprung wie das Zieldokument hat, ist der zurückgegebene Wert 0. **Stufe 1:** <pre>entryData.redirectStart > 0<br />  ? entryData.redirectStart - entryData.navigationStart<br />  : 0</pre> **Stufe 2:** entryData.redirectStart | 
|  **redirectTime** |  Zahl  |  Die nötige Zeit für die HTTP-Umleitung. Dies ist die Differenz zwischen `redirectStart` und `redirectEnd`.   |  **Stufe 1:**: entryData.redirectEnd – entryData.redirectStart **Stufe 2:**: entryData.redirectEnd – entryData.redirectStart | 
|  **workerStart** |  Zahl  |  Dies ist eine Eigenschaft der `PerformanceResourceTiming`-Schnittstelle. Dies markiert den Beginn der Worker-Thread-Operation. Dieses Attribut ist nicht erforderlich. |  **Wert:** Wenn ein Service-Worker-Thread bereits ausgeführt wird oder unmittelbar vor dem Starten des Service-Worker-Threads, gibt diese Eigenschaft die Zeit unmittelbar vor dem Aussenden von `FetchEvent` zurück. Es gibt 0 zurück, wenn die Ressource nicht von einem Service Worker abgefangen wird. **Stufe 1:** Nicht verfügbar **Stufe 2:** entryData.workerStart | 
|  **workerTime** |  Zahl  |  Wenn die Ressource von einem Service Worker abgefangen wird, gibt dies die Zeit zurück, die für den Worker-Thread-Betrieb benötigt wird. Dieses Attribut ist nicht erforderlich. |  **Stufe 1:** Nicht verfügbar  **Stufe 2:** <pre>entryData.workerStart > 0<br />   ? entryData.fetchStart - entryData.workerStart<br />   : 0</pre>  | 
|  **fetchStart** |  Zahl  |  Der Zeitpunkt, zu dem der Browser bereit ist, das Dokument mit einer HTTP-Anforderung abzurufen. Dies geschieht, bevor Sie einen Anwendungscache überprüfen. |  **Stufe 1:**  <pre>: entryData.fetchStart > 0<br />  ? entryData.fetchStart - entryData.navigationStart<br />  : 0</pre> **Stufe 2:** entryData.fetchStart | 
|  **domainLookupStart** |  Zahl  |  Der Zeitpunkt, zu dem die Domainsuche beginnt. |  **Wert:** Wenn eine dauerhafte Verbindung verwendet wird oder wenn die Informationen in einem Cache oder einer lokalen Ressource gespeichert sind, ist der Wert derselbe wie `fetchStart`. **Stufe 1:** <pre>entryData.domainLookupStart > 0<br />  ? entryData.domainLookupStart - entryData.navigationStart<br />  : 0</pre> **Stufe 2:** EntryData. domainLookupStart | 
|  **dns** |  Zahl  |  Die Zeit, die für die Domainsuche benötigt wird. |  **Wert:** Wenn die Ressourcen und DNS-Datensätze zwischengespeichert werden, ist der erwartete Wert 0. **Ebene 1:** EntryData. domainLookupEnd - Eingabedaten. domainLookupStart **Stufe 2:** EntryData. domainLookupEnd - Eingabedaten. domainLookupStart | 
|  **nextHopProtocol** |  Zeichenfolge  |  Eine Zeichenfolge, die das zum Abrufen der Ressource verwendete Netzwerkprotokoll darstellt. Dieses Attribut ist nicht erforderlich. |  **Stufe 1:** Nicht verfügbar **Stufe 2:** EntryData. nextHopProtocol | 
|  **connectStart** |  Zahl  |  Die Zeit unmittelbar bevor der Benutzeragent mit dem Herstellen der Verbindung zum Server beginnt, um das Dokument abzurufen. |  **Wert:** Wenn eine RFC2616 persistente Verbindung verwendet wird oder wenn das aktuelle Dokument aus relevanten Anwendungscaches oder lokalen Ressourcen abgerufen wird, gibt dieses Attribut den Wert von `domainLookupEnd` zurück. **Stufe 1:** <pre>entryData.connectStart > 0<br />  ? entryData.connectStart - entryData.navigationStart<br />  : 0</pre> **Stufe 2:** entryData.connectStart  | 
|  **connect** |  Zahl  |  Misst die Zeit, die zum Herstellen der Transportverbindungen oder zur Durchführung der SSL-Authentifizierung erforderlich ist. Es enthält auch die blockierte Zeit, die in Anspruch genommen wird, wenn zu viele gleichzeitige Anforderungen vom Browser ausgegeben werden.  |  **Stufe 1:** entryData.connectEnd – entryData.connectStart **Stufe 2:** entryData.connectEnd – entryData.connectStart | 
|  **secureConnectionStart** |  Zahl  |  Wenn das URL-Schema der aktuellen Seite „https“ lautet, gibt dieses Attribut umgehend die Zeit zurück, bevor der Benutzeragent den Handshake-Prozess startet, um die aktuelle Verbindung zu sichern. Es gibt 0 zurück, wenn HTTPS nicht verwendet wird. Weitere Informationen zu URL-Schemata finden Sie unter [URL-Darstellung](https://url.spec.whatwg.org/#concept-url-scheme).  |  **Formel:** EntryData. secureConnectionStart | 
|  **tlsTime** |  Zahl  |  Die Zeit, die benötigt wird, um einen SSL-Handshake abzuschließen.  |  **Stufe 1:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre> **Stufe 2:** <pre>entryData.secureConnectionStart > 0<br />   ? entryData.connectEnd - entryData.secureConnectionStart<br />   : 0</pre>  | 
|  **requestStart** |  Zahl  |  Die Zeit unmittelbar bevor der Benutzeragent beginnt, die Ressource vom Server oder von relevanten Anwendungscaches oder von lokalen Ressourcen anzufordern.   | **Stufe 1:** <pre>: entryData.requestStart > 0<br />  ? entryData.requestStart - entryData.navigationStart<br />  : 0<br /></pre> **Stufe 2:** entryData.requestStart | 
|  **timeToFirstByte** |  Zahl  |  Die Zeit, die benötigt wird, um das erste Byte an Informationen zu erhalten, nachdem eine Anforderung gestellt wurde. Diese Zeit ist relativ zu `startTime`.   | **Stufe 1:** entryData.responseStart – entryData.requestStart **Stufe 2:** entryData.responseStart – entryData.requestStart | 
|  **responseStart** |  Zahl  |  Die Zeit unmittelbar nachdem der HTTP-Parser des Benutzeragenten das erste Byte der Antwort von den relevanten Anwendungscaches oder von lokalen Ressourcen oder vom Server erhalten hat.   | **Stufe 1:** <pre>entryData.responseStart > 0<br />   ? entryData.responseStart - entryData.navigationStart<br />   : 0</pre> **Stufe 2:** entryData.responseStart   | 
|  **responseTime** |  Zeichenfolge  |  Die Zeit, die benötigt wird, um eine vollständige Antwort in Form von Bytes von den relevanten Anwendungs-Caches, von lokalen Ressourcen oder vom Server zu erhalten.   | **Stufe 1:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre> **Stufe 2:** <pre>entryData.responseStart > 0<br />  ? entryData.responseEnd - entryData.responseStart<br />  : 0</pre>  | 
|  **domInteractive** |  Zahl  |  Der Zeitpunkt, zu dem der Parser seine Arbeit am Hauptdokument beendet hat und das HTML-DOM erstellt wurde. Zu diesem Zeitpunkt wechselt `Document.readyState` zu „interaktiv“ und das entsprechende `readystatechange`-Ereignis wird ausgegeben.  | **Stufe 1:** <pre>entryData.domInteractive > 0<br />  ? entryData.domInteractive - entryData.navigationStart<br />  : 0</pre> **Stufe 2:** entryData.domInteractive  | 
|  **domContentLoadedEventStart** |  Zahl  |  Stellt den Zeitwert dar, der der Zeit unmittelbar vor dem Auslösen des Loaded-Ereignisses DOMContent durch das Benutzerprogramm im aktuellen Dokument entspricht. Das DOMContent Loaded-Ereignis wird ausgelöst, wenn das ursprüngliche HTML-Dokument vollständig geladen und analysiert wurde. Zu diesem Zeitpunkt hat das Haupt-HTML-Dokument die Analyse abgeschlossen, der Browser beginnt mit der Erstellung der Rendering-Baumstruktur und untergeordnete Ressourcen müssen noch geladen werden. Es wird nicht drauf gewartet, bis Stylesheets, Bilder und Subframes vollständig geladen sind.  | **Stufe 1:** <pre>entryData.domContentLoadedEventStart > 0<br />  ? entryData.domContentLoadedEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Ebene 2: EntryData**. domContentLoadedEventStart  | 
|  **domContentLoaded** |  Zahl  |  Die Start- und Endzeit der Erstellung der Rendering-Baumstruktur ist gekennzeichnet durch `domContentLoadedEventStart` und `domContentLoadedEventEnd`. Damit kann CloudWatch RUM die Ausführung verfolgen. Diese Eigenschaft ist die Differenz zwischen `domContentLoadedStart` und `domContentLoadedEnd`. Während dieser Zeit sind DOM und CSSOM bereit. Diese Eigenschaft wartet auf die Ausführung des Skripts, mit Ausnahme von asynchronen und dynamisch erstellten Skripten. Wenn die Skripten von Stylesheets abhängen, wartet `domContentLoaded` auch auf die Stylesheets. Es wartet nicht auf Bilder.   Die tatsächlichen Werte von `domContentLoadedStart` und `domContentLoadedEnd` nähern sich `domContentLoaded` im Netzwerkbereich von Google Chrome an. Es gibt die Erstellungszeit für die HTML-DOM\$1CSSOM-Rendering-Baumstruktur ab Beginn des Seitenladevorgangs an. Im Fall von Navigationsmetriken stellt der `domContentLoaded`-Wert die Differenz zwischen Start- und Endwerten dar. Dies ist ausschließlich die für das Herunterladen von untergeordneten Ressourcen und das Erstellen der Rendering-Baumstruktur benötigte Zeit.    | **Ebene 2:** EntryData. domContentLoadedEventEnd - Eingabedaten. domContentLoadedEventStart  **Stufe 2:** EntryData. domContentLoadedEventEnd - Eingabedaten. domContentLoadedEventStart  | 
|  **domComplete** |  Zahl  |  Die Zeit unmittelbar bevor der Browser die aktuelle Dokumentbereitschaft des aktuellen Dokuments als abgeschlossen festlegt. An diesem Punkt ist das Laden von untergeordneten Ressourcen wie Bildern abgeschlossen. Dies beinhaltet die Zeit, die für das Herunterladen blockierender Inhalte wie CSS und synchroner JavaScript Inhalte benötigt wird. Dies entspricht ungefähr `loadTime` im Netzwerkbereich von Google Chrome.   | **Stufe 1:** <pre>entryData.domComplete > 0<br />  ? entryData.domComplete - entryData.navigationStart<br />  : 0<br /></pre> **Stufe 2:** entryData.domComplete  | 
|  **domProcessingTime** |  Zahl  |  Die Gesamtzeit zwischen der Antwort und dem Start des Load-Ereignisses.  | **Ebene 1: EntryData**. loadEventStart - EntryData.ResponseEnd **Ebene 2: EntryData**. loadEventStart - EntryData.ResponseEnd  | 
|  **loadEventStart** |  Zahl  |  Die Zeit unmittelbar bevor das `load`-Ereignis des aktuellen Dokuments ausgelöst wird.  |  **Stufe 1:** <pre>entryData.loadEventStart > 0<br />  ? entryData.loadEventStart - entryData.navigationStart<br />  : 0<br /></pre> **Ebene 2: EntryData**. loadEventStart | 
|  **loadEventTime** |  Zahl  |  Differenz zwischen `loadEventStart` und `loadEventEnd`. Zusätzliche Funktionen oder Logik, die auf dieses Load-Ereignis warten, werden während dieser Zeit ausgelöst. |  **Ebene 1:** EntryData. loadEventEnd - Eingabedaten. loadEventStart **Stufe 2:** EntryData. loadEventEnd - Eingabedaten. loadEventStart | 
|  **duration** |  Zeichenfolge  |  Die Dauer entspricht der gesamten Ladezeit der Seite. Es zeichnet den Zeitpunkt für das Herunterladen der Hauptseite und aller synchronen untergeordneten Ressourcen sowie für das Rendern der Seite auf. Asynchrone Ressourcen wie Skripte werden später weiter heruntergeladen. Das ist die Differenz zwischen den Eigenschaften `loadEventEnd` und `startTime`.  | **Ebene 1:** EntryData. loadEventEnd - EntryData.NavigationStart **Stufe 2:** entryData.duration | 
|  **headerSize** |  Zahl  |  Gibt die Differenz zwischen `transferSize` und `encodedBodySize` zurück. Dieses Attribut ist nicht erforderlich.  | **Stufe 1:** Nicht verfügbar **Ebene 2**: EntryData.TransferSize - EntryData. encodedBodySize **Ebene 2:** EntryData.TransferSize - EntryData. encodedBodySize | 
|  **compressionRatio** |  Zahl  |  Das Verhältnis von `encodedBodySize` und `decodedBodySize`. Der Wert von `encodedBodySize` ist die komprimierte Größe der Ressource ohne die HTTP-Header. Der Wert von `decodedBodySize` ist die entkomprimierte Größe der Ressource ohne die HTTP-Header. Dieses Attribut ist nicht erforderlich.  | **Stufe 1:** Nicht verfügbar. **Stufe 2:**<pre>entryData.encodedBodySize > 0<br />  ? entryData.decodedBodySize / entryData.encodedBodySize<br />  : 0</pre>  | 
|  **navigationTimingLevel** |  Zahl  |  Die API-Version des Navigationszeitpunkts.  | **Wert:** 1 oder 2  | 

### Ressourcen-Ereignisschema
<a name="CloudWatch-RUM-datacollected-ResourceEvent"></a>

Ressourcen-Ereignisse werden nur erfasst, wenn die App-Überwachung die Leistungstelemetrie aktiviert hat.

Timestamp-Metriken basieren auf [The DOMHigh ResTimeStamp typedef](https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp). Bei Stufe 2 beziehen APIs sich alle Timings standardmäßig auf die. `startTime` Bei Stufe 1 APIs wird die `navigationStart` Metrik jedoch von den Zeitstempel-Metriken subtrahiert, um relative Werte zu erhalten. Alle Zeitstempelwerte sind in Millisekunden.

Vom Agent generierte Ressourcen-Ereignisse enthalten die folgenden Eigenschaften.


| Name | Typ | Description | Hinweise | 
| --- | --- | --- | --- | 
|  **targetUrl** |  Zeichenfolge  |  Gibt die URL der Ressource zurück.  |  **Formel:** [entryData.name](http://entrydata.name/) | 
|  **initiatorType** |  Zeichenfolge  |  Repräsentiert den Ressourcentyp, der das Leistungs-Ressourcenereignis ausgelöst hat.  |  **Wert:** „Ressource“ **Formel:** entryData.initiatorType | 
|  **duration** |  Zeichenfolge  |  Gibt die Differenz zwischen den Eigenschaften `responseEnd` und `startTime` zurück.Dieses Attribut ist nicht erforderlich.  | **Formel:** entryData.duration | 
|  **transferSize** |  Zahl  |  Gibt die Größe (in Oktetten) der abgerufenen Ressource zurück, einschließlich der Antwortheader-Felder und des Antwort-Nutzlasttextes.Dieses Attribut ist nicht erforderlich.  | **Formel:** entryData.transferSize | 
|  **fileType** |  Zeichenfolge  |  Erweiterungen, die vom Ziel-URL-Muster abgeleitet werden.  |   | 

### Größtes inhaltliches Zeichnungsereignisschema
<a name="CloudWatch-RUM-datacollected-LargestPaintEvent"></a>

Die größten inhaltlichen Zeichnungsereignisse enthalten die folgenden Eigenschaften.

Diese Ereignisse werden nur erfasst, wenn die App-Überwachung die Leistungstelemetrie aktiviert hat.


| Name | Description | 
| --- | --- | 
|  **Wert** |  Weitere Informationen finden Sie unter [Web Vitals](https://web.dev/vitals/) (Webdaten).  | 

### Erstes Eingabeverzögerungsereignis
<a name="CloudWatch-RUM-datacollected-FirstInputDelayEvent"></a>

Erste Eingabeverzögerungsereignisse enthalten die folgenden Eigenschaften.

Diese Ereignisse werden nur erfasst, wenn die App-Überwachung die Leistungstelemetrie aktiviert hat.


| Name | Description | 
| --- | --- | 
|  **Wert** |  Weitere Informationen finden Sie unter [Web Vitals](https://web.dev/vitals/) (Webdaten).  | 

### Kumulatives Layoutverschiebungs-Ereignis
<a name="CloudWatch-RUM-datacollected-CumulativeShift"></a>

Kumulative Layoutverschiebungs-Ereignisse enthalten die folgenden Eigenschaften.

Diese Ereignisse werden nur erfasst, wenn die App-Überwachung die Leistungstelemetrie aktiviert hat.


| Name | Description | 
| --- | --- | 
|  **Wert** |  Weitere Informationen finden Sie unter [Web Vitals](https://web.dev/vitals/) (Webdaten).  | 

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

HTTP-Ereignisse enthalten die folgenden Eigenschaften. Sie enthalten entweder ein `Response`-Feld oder ein `Error`-Feld, aber nicht beides.

Diese Ereignisse werden nur erfasst, wenn die App-Überwachung die HTTP-Telemetrie aktiviert hat.


| Name | Description | 
| --- | --- | 
|  **Anforderung** |  Das Anforderungsfeld enthält Folgendes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Antwort** |  Das Antwortfeld enthält die folgenden Elemente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 
|  **Fehler** |  Das Fehlerfeld enthält die folgenden Elemente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/CloudWatch-RUM-datacollected.html)  | 

### X-Ray-Ablaufverfolgungs-Ereignisschema
<a name="CloudWatch-RUM-datacollected-xraytraceEvent"></a>

Diese Ereignisse werden nur erfasst, wenn die App-Überwachung die X-Ray-Ablaufverfolgungs-Telemetrie aktiviert hat.

Weitere Informationen zu Ereignisschemas für die X-Ray-Ablaufverfolgung finden Sie unter [AWS X-Ray -Segmentdokumente](https://docs.aws.amazon.com/xray/latest/devguide/xray-api-segmentdocuments.html).

# Routenänderungs-Timing für Single-Page-Anwendungen
<a name="CloudWatch-RUM-route-change-timing"></a>

Wenn ein Benutzer in einer herkömmlichen mehrseitigen Anwendung das Laden neuer Inhalte anfordert, fordert der Benutzer eigentlich eine neue HTML-Seite vom Server an. Infolgedessen erfasst der CloudWatch RUM-Webclient die Ladezeiten anhand der regulären Performance-API-Metriken.

Einseitige Webanwendungen verwenden JavaScript jedoch Ajax, um die Benutzeroberfläche zu aktualisieren, ohne eine neue Seite vom Server zu laden. Single-Page-Aktualisierungen werden nicht von der Browser-Timing-API erfasst, sondern verwenden stattdessen das Routenänderungs-Timing.

CloudWatch RUM unterstützt die Überwachung sowohl ganzer Seitenladevorgänge vom Server als auch von einseitigen Updates, mit den folgenden Unterschieden:
+ Für das Routenänderungs-Timing gibt es keine browserseitig bereitgestellten Metriken wie `tlsTime` und `timeToFirstByte`.
+ Beim Routenänderungs-Timing hat das Feld `initiatorType` den Wert `route_change`. 

Der CloudWatch RUM-Webclient überwacht Benutzerinteraktionen, die zu einer Änderung der Route führen können, und wenn eine solche Benutzerinteraktion aufgezeichnet wird, zeichnet der Webclient einen Zeitstempel auf. Dann beginnt das Routenänderungs-Timing, wenn die beiden folgenden Punkte zutreffen:
+ Für die Routenänderung wurde eine Browserverlaufs-API verwendet (mit Ausnahme der Browserschaltflächen für „Weiter“ und „Zurück“).
+ Der zeitliche Abstand zwischen dem Zeitpunkt der Routenänderungserkennung und dem Zeitstempel der letzten Benutzerinteraktion beträgt weniger als 1 000 ms. Dadurch werden Datenverzerrungen vermieden.

Das gestartete Routenänderungs-Timing wird abgeschlossen, wenn keine laufenden AJAX-Anforderungen und DOM-Mutationen vorhanden sind. Anschließend wird der Zeitstempel der letzten abgeschlossenen Aktivität als Abschlusszeitstempel verwendet.

Für das Routenänderungs-Timing tritt ein Timeout auf, wenn AJAX-Anforderungen oder DOM-Mutationen länger als 10 Sekunden dauern (Standardeinstellung). In diesem Fall zeichnet der CloudWatch RUM-Webclient das Timing für diese Routenänderung nicht mehr auf.

Die Dauer eines Routenänderungsereignisses wird somit wie folgt berechnet:

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

# Verwalten Sie Ihre Anwendungen, die CloudWatch RUM verwenden
<a name="CloudWatch-RUM-manage"></a>

Verwenden Sie die Schritte in diesen Abschnitten, um die Verwendung von CloudWatch RUM durch Ihre Anwendungen zu verwalten.

**Topics**
+ [Wie finde ich einen Codeausschnitt, den ich bereits generiert habe?](CloudWatch-RUM-find-code-snippet.md)
+ [Bearbeiten Sie Ihre CloudWatch RUM-App-Monitor-Einstellungen](CloudWatch-RUM-edit-application.md)
+ [Beenden Sie die Verwendung von CloudWatch RUM oder das Löschen eines App-Monitors](CloudWatch-RUM-delete-appmonitor.md)

# Wie finde ich einen Codeausschnitt, den ich bereits generiert habe?
<a name="CloudWatch-RUM-find-code-snippet"></a>

Gehen Sie wie folgt vor, CloudWatch um einen RUM-Codeausschnitt zu finden, den Sie bereits für eine Anwendung generiert haben.

**Bereits generierten Codeausschnitt finden**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Navigieren Sie zur Registerkarte „**Konfiguration**“ im Abschnitt „**Codefragmente“.**

1. Wählen Sie für Ihre **jeweilige Instrumentierung die Option Kopieren/Herunterladen**.

# Bearbeiten Sie Ihre CloudWatch RUM-App-Monitor-Einstellungen
<a name="CloudWatch-RUM-edit-application"></a>

Gehen Sie folgendermaßen vor, um die Einstellungen einer App-Überwachung zu ändern. Sie können alle Einstellungen mit Ausnahme des Namens der App-Überwachung ändern.

**Um zu bearbeiten, wie Ihre Anwendung CloudWatch RUM verwendet**

1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie die Schaltfläche neben dem Namen der Anwendung aus und wählen Sie dann **Actions** (Aktionen), **Edit** (Bearbeiten) aus.

1. Sie können alle Einstellungen mit Ausnahme des Namens der Anwendung ändern. Weitere Informationen zu diesen Einstellungen finden Sie unter [Einen CloudWatch RUM-App-Monitor für eine Webanwendung erstellen](CloudWatch-RUM-get-started-create-app-monitor.md).

1. Wenn Sie fertig sind, wählen Sie **Speichern** aus.

   Durch das Ändern der Einstellungen wird der Codeausschnitt geändert. Sie müssen jetzt den aktualisierten Codeausschnitt in Ihre Anwendung einfügen.

1. **Nachdem der Codeausschnitt erstellt wurde, wählen Sie In die **Zwischenablage kopieren** oder **Herunterladen** und dann Fertig.**

   Fügen Sie den Codeausschnitt in Ihre Anwendung ein, um mit der Überwachung mit den neuen Einstellungen zu beginnen.

# Beenden Sie die Verwendung von CloudWatch RUM oder das Löschen eines App-Monitors
<a name="CloudWatch-RUM-delete-appmonitor"></a>

Um die Verwendung von CloudWatch RUM mit einer Anwendung zu beenden, entfernen Sie den Codeausschnitt, den RUM aus dem Code Ihrer Anwendung generiert hat.

Gehen Sie folgendermaßen vor, um eine RUM-App-Überwachung zu löschen.

**App-Überwachung löschen**

1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)

1. Wählen Sie im Navigationsbereich **Application Signals**, **RUM**.

1. Wählen Sie die Schaltfläche neben dem Namen der Anwendung aus und wählen Sie dann **Actions** (Aktionen), **Delete** (Löschen) aus.

1. Geben Sie in das Bestätigungsfeld **Delete** ein und wählen Sie dann **Delete** (Löschen).

1. Wenn Sie dies noch nicht getan haben, löschen Sie den CloudWatch RUM-Codeausschnitt aus dem Code Ihrer Anwendung.

# Problembehebung bei RUM CloudWatch
<a name="CloudWatch-RUM-troubleshooting"></a>

Dieser Abschnitt enthält Tipps zur Behebung von Problemen mit CloudWatch RUM.

## Es gibt keine Daten für meine Bewerbung
<a name="CloudWatch-RUM-troubleshooting-nodata"></a>

Stellen Sie zunächst sicher, dass der Codeausschnitt korrekt in Ihre Anwendung eingefügt wurde. Weitere Informationen finden Sie unter [Fügen Sie den CloudWatch App-Monitor-Codeausschnitt in Ihre Anwendung ein](CloudWatch-RUM-get-started-insert-code-snippet.md).

Wenn dies nicht das Problem ist, gab es möglicherweise noch keinen Datenverkehr zu Ihrer Anwendung. Generieren Sie etwas Datenverkehr, indem Sie auf Ihre Anwendung genauso zugreifen wie ein Benutzer.

## Für meine Anwendung wurden keine Daten mehr aufgezeichnet
<a name="CloudWatch-RUM-troubleshooting-nonewdata"></a>

Ihre Anwendung wurde möglicherweise aktualisiert und enthält jetzt keinen CloudWatch RUM-Codeausschnitt mehr. Überwachen Sie Ihren Anwendungscode.

Eine andere Möglichkeit besteht darin, dass jemand den Codeausschnitt aktualisiert, ihn aber nicht in die Anwendung eingefügt hat. Finden Sie den aktuell korrekten Codeausschnitt, indem Sie den Anweisungen unter [Wie finde ich einen Codeausschnitt, den ich bereits generiert habe?](CloudWatch-RUM-find-code-snippet.md) folgen und ihn mit dem Codeausschnitt vergleichen, der in Ihre Anwendung eingefügt ist.