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.

# Konfiguration von Observability-Funktionen in AWS SDK for Java 2.x
<a name="observability"></a>

Telemetrie ist die automatisierte Erfassung und Übertragung von Daten aus entfernten Quellen, mit denen Sie das Verhalten Ihres Systems überwachen und analysieren können. 

Die Beobachtbarkeit im SDK for Java 2.x bietet Entwicklern umfassende Einblicke in die Interaktion ihrer Java-Anwendungen AWS-Services mithilfe umfangreicher Telemetriedaten, die den gesamten Anforderungszyklus erfassen. Diese Funktionen ermöglichen es Ihnen, Telemetriesignale wie Metriken, Protokolle und Traces zu sammeln, zu analysieren und zu visualisieren. So können Sie Anforderungsmuster überwachen, Engpässe identifizieren und die AWS Interaktionen Ihrer Anwendung optimieren, um die Zuverlässigkeit und Leistung zu verbessern.

**Topics**
+ [Kennzahlen](metrics.md)
+ [Überwachen](monitoring-overview.md)
+ [Protokollierung](logging-slf4j.md)

# Veröffentlichen Sie SDK-Metriken aus dem AWS SDK for Java 2.x
<a name="metrics"></a>

Mit dem können AWS SDK for Java 2.x Sie Metriken über die Service-Clients und Anfragen in Ihrer Anwendung sammeln, die Ausgabe in Amazon CloudWatch Logs analysieren und dann darauf reagieren.

Standardmäßig ist die Erfassung von Metriken im SDK deaktiviert. Dieses Thema hilft Ihnen dabei, es zu aktivieren und zu konfigurieren.

## Erste Schritte mit SDK-Metriken
<a name="getting-started-with-metrics"></a>

Um die Erfassung von Metriken in Ihrer Anwendung zu aktivieren, wählen Sie die für Ihren Anwendungsfall geeignete Implementierung der `[MetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/MetricPublisher.html)` Schnittstelle aus und folgen Sie den detaillierten Anweisungen zur Einrichtung:

**Für Anwendungen mit langer Laufzeit:**
+ Verwenden von `[CloudWatchMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/cloudwatch/CloudWatchMetricPublisher.html)`
+ Vollständige Anweisungen zur Einrichtung, Codebeispiele und Konfigurationsoptionen finden Sie unter [Veröffentlichen von SDK-Metriken von Anwendungen mit langer Laufzeit](metric-pub-impl-cwmp.md).

**Für AWS Lambda Funktionen:**
+ Verwenden von `[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)`
+ Vollständige Setup-Anweisungen, Abhängigkeiten und Lambda-spezifische Konfigurationen finden Sie unter [SDK-Metriken für AWS Lambda Funktionen veröffentlichen](metric-pub-impl-emf.md).

**Zur Fehlerbehebung und zur Konsolenausgabe:**
+ Verwenden von `[LoggingMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/LoggingMetricPublisher.html)`
+ Anweisungen [zur Einrichtung, Formatierungsoptionen und Beispiele für lokale Entwicklung und Problembehebung finden Sie unter SDK-Metriken für Entwicklung und Debugging an die Konsole ausgeben](metric-pub-impl-logging.md).

## Schnelle Implementierungsvorschau
<a name="quick-implementation-preview"></a>

So sehen die Aktivierungsmetriken für jeden Anwendungsfall aus:

**Anwendungen mit langer Laufzeit:**

```
MetricPublisher metricsPub = CloudWatchMetricPublisher.create();
DynamoDbClient ddb = DynamoDbClient.builder()
    .overrideConfiguration(c -> c.addMetricPublisher(metricsPub))
    .build();
```

**Lambda-Funktionen:**

```
EmfMetricLoggingPublisher emfPublisher = EmfMetricLoggingPublisher.builder()
    .namespace("MyApp")
    .build();
DynamoDbClient dynamoDb = DynamoDbClient.builder()
    .overrideConfiguration(c -> c.addMetricPublisher(emfPublisher))
    .build();
```

**Entwicklung und Debugging:**

```
MetricPublisher loggingPublisher = LoggingMetricPublisher.create();
S3Client s3 = S3Client.builder()
    .overrideConfiguration(c -> c.addMetricPublisher(loggingPublisher))
    .build();
```

## Beschränkung der Metriken des AWS CRT-basierten S3-Clients
<a name="metrics-using-s3-crt-based-client"></a>

Der [AWS CRT-basierte S3-Client unterstützt derzeit keine Erfassung](crt-based-s3-client.md) von SDK-Metriken. Der Builder für eine AWS CRT-basierte S3-Client-Instanz bietet keine Methoden zur Konfiguration von [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3CrtAsyncClientBuilder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3CrtAsyncClientBuilder.html)Metrik-Publishern.

## Wann sind Metriken verfügbar?
<a name="when-are-metrics-available"></a>

Metriken sind in der Regel innerhalb von 5-10 Minuten verfügbar, nachdem sie vom SDK for Java ausgegeben wurden. Genaue up-to-date Metriken finden Sie mindestens 10 Minuten nach der Ausgabe der Metriken aus Ihren Java-Anwendungen in Cloudwatch. 

## Welche Informationen werden gesammelt?
<a name="what-information-is-collected"></a>

Die Erfassung von Metriken umfasst Folgendes:
+ Anzahl der API-Anfragen, einschließlich der Frage, ob sie erfolgreich waren oder nicht
+ Informationen über die von AWS-Services Ihnen aufgerufenen API-Anfragen, einschließlich der zurückgegebenen Ausnahmen
+ Die Dauer verschiedener Operationen wie Marshalling, Signierung und HTTP-Anfragen
+ HTTP-Client-Metriken, wie die Anzahl der offenen Verbindungen, die Anzahl der ausstehenden Anfragen und der Name des verwendeten HTTP-Clients

**Anmerkung**  
Die verfügbaren Metriken variieren je nach HTTP-Client.

Eine vollständige Liste finden Sie unter [Service-Client-Metriken](metrics-list.md).

## Wie kann ich diese Informationen verwenden?
<a name="how-can-i-use-this-information"></a>

Sie können die vom SDK gesammelten Metriken verwenden, um die Service-Clients in Ihrer Anwendung zu überwachen. Sie können sich allgemeine Nutzungstrends ansehen, Anomalien identifizieren, zurückgegebene Service-Client-Ausnahmen überprüfen oder sich ein bestimmtes Problem genauer ansehen. Mithilfe von Amazon CloudWatch Logs können Sie auch Alarme erstellen, die Sie benachrichtigen, sobald Ihre Anwendung einen von Ihnen definierten Zustand erreicht.

Weitere Informationen finden Sie unter [Verwenden von Amazon CloudWatch Logs-Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) und [Verwenden von Amazon CloudWatch Logs-Alarmen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) im [Amazon CloudWatch Logs-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).

# Veröffentlichen Sie SDK-Metriken von Anwendungen mit langer Laufzeit mithilfe der AWS SDK for Java 2.x
<a name="metric-pub-impl-cwmp"></a>

Da die `[CloudWatchMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/cloudwatch/CloudWatchMetricPublisher.html)` Implementierung Metriken aggregiert und regelmäßig verzögert auf Amazon hochlädt, eignet sich ihre Verwendung am besten für Anwendungen CloudWatch mit langer Laufzeit. 

Die Standardeinstellungen des Metrik-Publishers sollen den Speicherverbrauch und die CloudWatch Kosten minimieren und gleichzeitig einen nützlichen Einblick in die Metrikdaten bieten.

## Einrichtung
<a name="prerequisitesmetrics"></a>

Führen Sie die folgenden Schritte aus`CloudWatchMetricPublisher`, bevor Sie Metriken mithilfe von aktivieren und verwenden können.

### Schritt 1: Fügen Sie die erforderliche Abhängigkeit hinzu
<a name="cwmp-set-up-deps"></a>

Konfigurieren Sie Ihre Projektabhängigkeiten (z. B. in Ihrer `pom.xml` `build.gradle` OR-Datei) so, dass die Version `2.14.0` oder eine neuere Version von verwendet wird AWS SDK für Java.

Fügen Sie die artifactId `cloudwatch-metric-publisher` mit der Versionsnummer `2.14.0` oder später in die Abhängigkeiten Ihres Projekts ein.

Beispiel:

```
<project>
  <dependencyManagement>
   <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>[2.30.11](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)</version>  <!-- Navigate the link to see the latest version. -->
        <type>pom</type>
        <scope>import</scope>
      </dependency>
   </dependencies>
  </dependencyManagement>
  <dependencies>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>cloudwatch-metric-publisher</artifactId>
   </dependency>
  </dependencies>
</project>
```

### Schritt 2: Konfigurieren Sie die erforderlichen Berechtigungen
<a name="cwmp-set-up-perms"></a>

Aktivieren Sie die `cloudwatch:PutMetricData` Berechtigungen für die IAM-Identität, die vom Herausgeber der Metriken verwendet wird, damit das SDK for Java Metriken schreiben kann.

## Aktivieren Sie Metriken für eine bestimmte Anfrage
<a name="enable-metrics-for-a-specific-request"></a>

Die folgende Klasse zeigt, wie Sie den CloudWatch Metrik-Publisher für eine Anfrage an Amazon DynamoDB aktivieren. Es verwendet die Standardkonfiguration für den Metrik-Publisher.

```
import software.amazon.awssdk.metrics.MetricPublisher;
import software.amazon.awssdk.metrics.publishers.cloudwatch.CloudWatchMetricPublisher;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;

public class DefaultConfigForRequest {
    // Use one MetricPublisher for your application. It can be used with requests or service clients.
    static MetricPublisher metricsPub = CloudWatchMetricPublisher.create();

    public static void main(String[] args) {
        DynamoDbClient ddb = DynamoDbClient.create();
        // Publish metrics the for ListTables operation.
        ddb.listTables(ListTablesRequest.builder()
            .overrideConfiguration(c -> c.addMetricPublisher(metricsPub))
            .build());

        // Perform more work in your application.

        // A MetricsPublisher has its own lifecycle independent of any service client or request that uses it.
        // If you no longer need the publisher, close it to free up resources.
        metricsPub.close();  // All metrics stored in memory are flushed to CloudWatch.

        // Perform more work with the DynamoDbClient instance without publishing metrics.
        // Close the service client when you no longer need it.
        ddb.close();
    }
}
```

**Wichtig**  
Stellen Sie sicher, dass Ihre Anwendung die `[MetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/MetricPublisher.html)` Instanz `close` aufruft, wenn der Service Client nicht mehr verwendet wird. Wenn Sie dies nicht tun, können Thread- oder Dateideskriptorlecks auftreten.

## Aktivieren Sie Übersichtsmetriken für einen bestimmten Service-Client
<a name="enable-metrics-for-a-specific-service-client"></a>

Der folgende Codeausschnitt zeigt, wie Sie einen CloudWatch Metrik-Publisher mit Standardeinstellungen für einen Service Client aktivieren.

```
MetricPublisher metricsPub = CloudWatchMetricPublisher.create();

DynamoDbClient ddb = DynamoDbClient.builder()
          .overrideConfiguration(c -> c.addMetricPublisher(metricsPub))
          .build();
```

## Passen Sie einen Herausgeber für Metriken an CloudWatch
<a name="customize-metrics-publisher"></a>

In der folgenden Klasse wird gezeigt, wie Sie eine benutzerdefinierte Konfiguration für den Metrik-Publisher für einen bestimmten Service-Client einrichten. Zu den Anpassungen gehören das Laden eines bestimmten Profils, die Angabe einer AWS Region, in die der Herausgeber der Metriken Anfragen sendet, und die Anpassung, wie oft der Herausgeber Metriken sendet. CloudWatch

```
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.metrics.MetricPublisher;
import software.amazon.awssdk.metrics.publishers.cloudwatch.CloudWatchMetricPublisher;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.cloudwatch.CloudWatchAsyncClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;

import java.time.Duration;

public class CustomConfigForDDBClient {
    // Use one MetricPublisher for your application. It can be used with requests or service clients.
    static MetricPublisher metricsPub = CloudWatchMetricPublisher.builder()
        .cloudWatchClient(CloudWatchAsyncClient.builder()
            .region(Region.US_WEST_2)
            .credentialsProvider(ProfileCredentialsProvider.create("cloudwatch"))
            .build())
        .uploadFrequency(Duration.ofMinutes(5))
        .maximumCallsPerUpload(100)
        .namespace("ExampleSDKV2Metrics")
        .detailedMetrics(CoreMetric.API_CALL_DURATION)
        .build();

    public static void main(String[] args) {
        DynamoDbClient ddb = DynamoDbClient.builder()
            .overrideConfiguration(c -> c.addMetricPublisher(metricsPub))
            .build();
        // Publish metrics for DynamoDB operations.
        ddb.listTables();
        ddb.describeEndpoints();
        ddb.describeLimits();
        // Perform more work in your application.

        // A MetricsPublisher has its own lifecycle independent of any service client or request that uses it.
        // If you no longer need the publisher, close it to free up resources.
        metricsPub.close();  // All metrics stored in memory are flushed to CloudWatch.


        // Perform more work with the DynamoDbClient instance without publishing metrics.
        // Close the service client when you no longer need it.
        ddb.close();
    }
}
```

Die im vorherigen Snippet gezeigten Anpassungen haben die folgenden Auswirkungen.
+ Mit `cloudWatchClient` dieser Methode können Sie den CloudWatch Client anpassen, der zum Senden von Metriken verwendet wird. In diesem Beispiel verwenden wir eine andere Region als die Standardregion *us-east-1*, in die der Client Metriken sendet. Wir verwenden auch ein anderes benanntes Profil, *cloudwatch*, dessen Anmeldeinformationen zur Authentifizierung von Anfragen verwendet werden. CloudWatch Diese Anmeldeinformationen müssen über die erforderlichen Berechtigungen verfügen. `cloudwatch:PutMetricData`
+ Mit `uploadFrequency` dieser Methode können Sie angeben, wie oft der Herausgeber Metriken hochlädt. CloudWatch Die Standardeinstellung ist einmal pro Minute.
+ Die `maximumCallsPerUpload` Methode begrenzt die Anzahl der Aufrufe pro Upload. Der Standardwert lautet „unbegrenzt“.
+ Standardmäßig veröffentlicht das SDK for Java 2.x Metriken unter dem `AwsSdk/JavaSdk2` Namespace. Sie können die `namespace` Methode verwenden, um einen anderen Wert anzugeben.
+ Standardmäßig veröffentlicht das SDK zusammenfassende Metriken. Übersichtsmetriken bestehen aus Durchschnitt, Minimum, Maximum, Summe und Stichprobenanzahl. Durch die Angabe einer oder mehrerer SDK-Metriken in der `detailedMetrics` Methode veröffentlicht das SDK zusätzliche Daten für jede Metrik. Diese zusätzlichen Daten ermöglichen Perzentilstatistiken wie p90 und p99, die Sie abfragen können. CloudWatch Die detaillierten Metriken sind besonders nützlich für Latenzmetriken wie`APICallDuration`, mit denen die Latenz für SDK-Client-Anfragen gemessen end-to-end wird. Sie können Felder der `[CoreMetric](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/metrics/CoreMetric.html)` Klasse verwenden, um andere gängige SDK-Metriken anzugeben. 

**Nächste Schritte:** Wenn Sie auch mit Lambda-Funktionen arbeiten, finden Sie unter [SDK-Metriken veröffentlichen Informationen zu AWS Lambda Funktionen für die](metric-pub-impl-emf.md) Veröffentlichung von EMF-basierten Metriken.

# Veröffentlichen Sie SDK-Metriken für AWS Lambda Funktionen mit dem AWS SDK for Java 2.x
<a name="metric-pub-impl-emf"></a>

Da Lambda-Funktionen in der Regel Millisekunden bis Minuten lang ausgeführt werden, besteht bei jeder Verzögerung beim Senden der Metriken die Gefahr eines `CloudWatchMetricPublisher` Datenverlusts. 

`[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)`bietet einen geeigneteren Ansatz, indem Metriken sofort als strukturierte Protokolleinträge im [CloudWatch Embedded Metric Format](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format.html) (EMF) geschrieben werden. `EmfMetricLoggingPublisher`funktioniert in Ausführungsumgebungen mit integrierter Integration mit Amazon CloudWatch Logs wie AWS Lambda Amazon Elastic Container Service.

## Einrichtung
<a name="metric-pub-impl-emf-set-up"></a>

Führen Sie die folgenden Schritte aus`EmfMetricLoggingPublisher`, bevor Sie Metriken mithilfe von aktivieren und verwenden können.

### Schritt 1: Fügen Sie die erforderliche Abhängigkeit hinzu
<a name="metric-pub-impl-emf-set-up-deps"></a>

Konfigurieren Sie Ihre Projektabhängigkeiten (z. B. in Ihrer `pom.xml` `build.gradle` OR-Datei) so, dass die Version `2.30.3` oder eine neuere Version von verwendet wird AWS SDK für Java.

Fügen Sie die artifactId `emf-metric-logging-publisher` mit der Versionsnummer `2.30.3` oder später in die Abhängigkeiten Ihres Projekts ein.

Beispiel:

```
<project>
  <dependencyManagement>
   <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>[2.30.11](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)</version>  <!-- Navigate the link to see the latest version. -->
        <type>pom</type>
        <scope>import</scope>
      </dependency>
   </dependencies>
  </dependencyManagement>
  <dependencies>
   <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>emf-metric-logging-publisher</artifactId>
   </dependency>
  </dependencies>
</project>
```

### Schritt 2: Konfigurieren Sie die erforderlichen Berechtigungen
<a name="metric-pub-impl-emf-set-up-perm"></a>

Aktivieren Sie die `logs:PutLogEvents` Berechtigungen für die IAM-Identität, die vom Herausgeber der Metriken verwendet wird, damit das SDK for Java Protokolle im EMF-Format schreiben kann.

### Schritt 3: Protokollierung einrichten
<a name="metric-pub-impl-emf-set-up-logger"></a>

Um eine korrekte Erfassung der Messwerte zu gewährleisten, konfigurieren Sie Ihre Protokollierung so, dass sie auf der Konsole oder `INFO` niedriger ausgegeben wird (z. B.`DEBUG`). In Ihrer `log4j2.xml` Datei:

```
<Loggers>
  <Root level="WARN">
   <AppenderRef ref="ConsoleAppender"/>
  </Root>
  <Logger name="software.amazon.awssdk.metrics.publishers.emf.EmfMetricLoggingPublisher" level="INFO" />
</Loggers>
```

Weitere Informationen zum Einrichten einer `log4j2.xml` Datei finden Sie im [Thema Protokollierung](logging-slf4j.md) in diesem Handbuch. 

## Konfigurieren und verwenden `EmfMetricLoggingPublisher`
<a name="metric-pub-impl-emf-use"></a>

Die folgende Lambda-Funktionsklasse erstellt und konfiguriert zunächst eine `EmfMetricLoggingPublisher` Instance und verwendet sie dann mit einem Amazon DynamoDB-Serviceclient:

```
public class GameIdHandler implements RequestHandler<Map<String, String>, String> {
    private final EmfMetricLoggingPublisher emfPublisher;
    private final DynamoDbClient dynamoDb;

    public GameIdHandler() {
        // Build the publisher. 
        this.emfPublisher = EmfMetricLoggingPublisher.builder()
                .namespace("namespace")
                .dimensions(CoreMetric.SERVICE_ID,
                        CoreMetric.OPERATION_NAME)
                .build();
        // Add the publisher to the client.
        this.dynamoDb = DynamoDbClient.builder()
                .overrideConfiguration(c -> c.addMetricPublisher(emfPublisher))
                .region(Region.of(System.getenv("AWS_REGION")))
                .build();
    }

    @Override
    public String handleRequest(Map<String, String> event, Context context) {
        Map<String, AttributeValue> gameItem = new HashMap<>();

        gameItem.put("gameId", AttributeValue.builder().s(event.get("id")).build());

        PutItemRequest putItemRequest = PutItemRequest.builder()
                .tableName("games")
                .item(gameItem)
                .build();

        dynamoDb.putItem(putItemRequest);

        return "Request handled";
    }
}
```

Wenn der DynamoDB-Client die `putItem` Methode ausführt, veröffentlicht er automatisch Metriken in einem CloudWatch Log-Stream im EMF-Format. 

### Beispiel für ein EMF-Protokollereignis
<a name="emf-logged-output"></a>

Wenn Sie beispielsweise das folgende Ereignis an die GameHandler Lambda-Funktion senden, wobei die Protokollierung wie oben gezeigt konfiguriert ist:

```
{
  "id": "23456"
}
```

Nachdem die Funktion das Ereignis verarbeitet hat, finden Sie zwei Protokollereignisse, die dem folgenden Beispiel ähneln. Das JSON-Objekt im zweiten Ereignis enthält die Java SDK-Metrikdaten für den `PutItem` Vorgang mit DynamoDB.

Wenn ein Protokollereignis im EMF-Format CloudWatch empfangen wird, analysiert es automatisch das strukturierte JSON, um Metrikdaten zu extrahieren. CloudWatch erstellt dann entsprechende Metriken und speichert gleichzeitig den ursprünglichen Protokolleintrag in CloudWatch Logs.

```
2025-07-11 15:58:30 [main] INFO  org.example.GameIdHandler:39 - Received map: {id=23456}

2025-07-11 15:58:34 [main] INFO  software.amazon.awssdk.metrics.publishers.emf.EmfMetricLoggingPublisher:43 - 
{
    "_aws": {
        "Timestamp": 1752249513975,
        "LogGroupName": "/aws/lambda/GameId",
        "CloudWatchMetrics": [
            {
                "Namespace": "namespace",
                "Dimensions": [
                    [
                        "OperationName",
                        "ServiceId"
                    ]
                ],
                "Metrics": [
                    {
                        "Name": "AvailableConcurrency"
                    },
                    {
                        "Name": "PendingConcurrencyAcquires"
                    },
                    {
                        "Name": "ServiceCallDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "EndpointResolveDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "MaxConcurrency"
                    },
                    {
                        "Name": "BackoffDelayDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "MarshallingDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "LeasedConcurrency"
                    },
                    {
                        "Name": "SigningDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "ConcurrencyAcquireDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "ApiCallSuccessful"
                    },
                    {
                        "Name": "RetryCount"
                    },
                    {
                        "Name": "UnmarshallingDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "ApiCallDuration",
                        "Unit": "Milliseconds"
                    },
                    {
                        "Name": "CredentialsFetchDuration",
                        "Unit": "Milliseconds"
                    }
                ]
            }
        ]
    },
    "AvailableConcurrency": 0,
    "PendingConcurrencyAcquires": 0,
    "OperationName": "PutItem",
    "ServiceCallDuration": 1339,
    "EndpointResolveDuration": 81,
    "MaxConcurrency": 50,
    "BackoffDelayDuration": 0,
    "ServiceId": "DynamoDB",
    "MarshallingDuration": 181,
    "LeasedConcurrency": 1,
    "SigningDuration": 184,
    "ConcurrencyAcquireDuration": 83,
    "ApiCallSuccessful": 1,
    "RetryCount": 0,
    "UnmarshallingDuration": 85,
    "ApiCallDuration": 1880,
    "CredentialsFetchDuration": 138
}
```

Die [API-Dokumentation](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.Builder.html) für `EmfMetricLoggingPublisher.Builder` zeigt die Konfigurationsoptionen, die Sie verwenden können.

Sie können die EMF-Metrikprotokollierung auch für eine einzelne Anfrage aktivieren, wie [für gezeigt](metric-pub-impl-cwmp.md#enable-metrics-for-a-specific-request). CloudWatchMetricPublisher

**Nächste Schritte:** Informationen zu Anwendungen mit langer Laufzeit finden Sie unter [Veröffentlichen von SDK-Metriken aus Anwendungen mit langer Laufzeit](metric-pub-impl-cwmp.md) für die Veröffentlichung von CloudWatch basierten Metriken.

# Geben Sie SDK-Metriken auf der Konsole aus, indem Sie AWS SDK for Java 2.x
<a name="metric-pub-impl-logging"></a>

Die `[LoggingMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/LoggingMetricPublisher.html)` Implementierung gibt Metriken direkt an die Konsole oder in die Protokolldateien Ihrer Anwendung aus. Dieser Ansatz ist ideal für die Entwicklung, das Debuggen und um zu verstehen, welche Metriken das SDK sammelt, ohne externe Dienste wie Amazon CloudWatch zu benötigen.

Im Gegensatz zu `CloudWatchMetricPublisher` und `EmfMetricLoggingPublisher` `LoggingMetricPublisher` bietet sofortige Ausgabe ohne Verzögerungen oder externe Abhängigkeiten. Dadurch eignet es sich perfekt für lokale Entwicklungs- und Problemlösungsszenarien.

## Wann sollte es verwendet werden LoggingMetricPublisher
<a name="logging-metric-publisher-when-to-use"></a>

Verwenden Sie `LoggingMetricPublisher`, wenn Sie Folgendes benötigen:
+ Erfassung von Metriken während der Entwicklung debuggen
+ Verstehen Sie, welche Metriken das SDK für Ihren Betrieb sammelt
+ Beheben Sie Leistungsprobleme lokal
+ Testen Sie die Erfassung von Metriken ohne Abhängigkeiten von externen Diensten
+ Sehen Sie sich Metriken sofort in Ihrer Konsole oder in Ihren Protokolldateien an

**Anmerkung**  
`LoggingMetricPublisher`wird nicht für Produktionsumgebungen empfohlen, in denen Sie persistente Speicher- und Analysefunktionen für Metriken benötigen.

## Richten Sie die Konsolenprotokollierung für Metriken ein
<a name="logging-metric-publisher-setup"></a>

Um die `LoggingMetricPublisher` Ausgabe zu sehen, konfigurieren Sie Ihr Logging-Framework so, dass `INFO` Level-Meldungen angezeigt werden. Die folgende `log4j2.xml` Konfiguration stellt sicher, dass Metriken in Ihrer Konsole angezeigt werden:

```
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="INFO">
            <AppenderRef ref="ConsoleAppender"/>
        </Root>
        <!-- Ensure LoggingMetricPublisher output appears. -->
        <Logger name="software.amazon.awssdk.metrics.LoggingMetricPublisher" level="INFO" />
    </Loggers>
</Configuration>
```

Diese Konfiguration weist das SDK an, Metriken auf der entsprechenden `INFO` Ebene an Ihre Konsole auszugeben. Die `LoggingMetricPublisher` Logger-Konfiguration stellt sicher, dass die Metrikausgabe auch dann angezeigt wird, wenn Ihr Root-Logger eine höhere Ebene wie `WARN` oder verwendet`ERROR`.

## Aktivieren Sie Konsolenmetriken für einen Service-Client
<a name="logging-metric-publisher-basic-usage"></a>

Das folgende Beispiel zeigt, wie Sie einen erstellen `LoggingMetricPublisher` und ihn mit einem Amazon Simple Storage Service-Client verwenden:

```
import software.amazon.awssdk.metrics.LoggingMetricPublisher;
import software.amazon.awssdk.metrics.MetricPublisher;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;

// Create a LoggingMetricPublisher with default settings.
MetricPublisher metricPublisher = LoggingMetricPublisher.create();

// Add the publisher to your service client.
S3Client s3Client = S3Client.builder()
    .region(Region.US_EAST_1)
    .overrideConfiguration(config -> config.addMetricPublisher(metricPublisher))
    .build();

// Make requests - metrics will appear in your console.
s3Client.listBuckets();

// Clean up resources.
metricPublisher.close();
s3Client.close();
```

## Wählen Sie das metrische Ausgabeformat
<a name="logging-metric-publisher-formatting-options"></a>

`LoggingMetricPublisher`unterstützt zwei Ausgabeformate:
+ **PLAIN-Format (Standard):** Gibt Metriken als kompakte, einzeilige Einträge aus
+ **PRETTY-Format:** Gibt Metriken in einem mehrzeiligen, für Menschen lesbaren Format aus

Das folgende Beispiel zeigt, wie das PRETTY-Format verwendet wird, um das Lesen während der Entwicklung zu erleichtern:

```
import org.slf4j.event.Level;
import software.amazon.awssdk.metrics.LoggingMetricPublisher;

// Create a LoggingMetricPublisher with PRETTY format.
MetricPublisher prettyMetricPublisher = LoggingMetricPublisher.create(
    Level.INFO, 
    LoggingMetricPublisher.Format.PRETTY
);

// Use with your service client.
S3Client s3Client = S3Client.builder()
    .region(Region.US_EAST_1)
    .overrideConfiguration(config -> config.addMetricPublisher(prettyMetricPublisher))
    .build();
```

## Vollständiges Beispiel
<a name="logging-metric-publisher-complete-example"></a>

Das folgende Beispiel zeigt die Verwendung `LoggingMetricPublisher` auf zwei Arten:
+ Auf der Ebene des Serviceclients
+ Für eine einzige Anfrage

```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.event.Level;
import software.amazon.awssdk.metrics.LoggingMetricPublisher;
import software.amazon.awssdk.metrics.MetricPublisher;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.ListBucketsRequest;
import software.amazon.awssdk.services.s3.model.ListBucketsResponse;

/**
 * Demonstrates how to use LoggingMetricPublisher with AWS S3 SDK for Java 2.x.
 * <p>
 * This demo focuses on the S3 listBuckets operation to show how metrics are collected
 * and logged to the console for development and debugging purposes.
 * <p>
 * LoggingMetricPublisher is ideal for:
 * - Development and debugging
 * - Console output for troubleshooting
 * - Understanding what metrics are being collected
 * - Testing metric collection without external dependencies
 */
public class S3LoggingMetricPublisherDemo {

    private static final Logger logger = LoggerFactory.getLogger(S3LoggingMetricPublisherDemo.class);

    public static void main(String[] args) {
        S3LoggingMetricPublisherDemo demo = new S3LoggingMetricPublisherDemo();
        demo.demonstrateUsage();
    }

    /**
     * Demonstrates basic usage with S3Client and metrics enabled at the client level.
     */
    private void demonstrateUsage() {

        // Create a LoggingMetricPublisher with default settings. The SDK logs metrics as text in a single line.
        // The default settings are equivalent to using `LoggingMetricPublisher.Format.PLAIN`.

        MetricPublisher metricPublisher = LoggingMetricPublisher.create();

        // Create an S3 client with metrics enabled.
        try (S3Client s3Client = S3Client.builder()
                .region(Region.US_EAST_1)
                .overrideConfiguration(config -> config.addMetricPublisher(metricPublisher))
                .build()) {

            // Make the listBuckets request - metrics will be logged to console.
            ListBucketsResponse response = s3Client.listBuckets(ListBucketsRequest.builder().build());

            // The next block shows the using a different LoggingMetricPublisher with a `PRETTY` format.
            // Since the metric publisher is added to the request using the `overrideConfiguration`, this formatting
            // applies only to the one request.
            try {
                s3Client.listBuckets(ListBucketsRequest.builder()
                        .overrideConfiguration(config -> config
                                .addMetricPublisher(LoggingMetricPublisher.create(
                                        Level.INFO, LoggingMetricPublisher.Format.PRETTY)))
                        .build());
            } catch (Exception e) {
                logger.info("Request failed with metrics logged: {}", e.getMessage());
            }
            logger.info("Found {} buckets in your AWS account.", response.buckets().size());

        } catch (Exception e) {
            logger.error("Error during S3 operation: {}", e.getMessage());
            logger.info("Note: This is expected if AWS credentials are not configured.");
        }

        // Close the metric publisher to flush any remaining metrics.
        metricPublisher.close();
    }
}
```

Der Code protokolliert Folgendes auf der Konsole:

```
INFO  LoggingMetricPublisher - Metrics published: MetricCollection(name=ApiCall, metrics=[MetricRecord(metric=MarshallingDuration, value=PT0.005409792S), MetricRecord(metric=RetryCount, value=0), MetricRecord(metric=ApiCallSuccessful, value=true), MetricRecord(metric=OperationName, value=ListBuckets), MetricRecord(metric=EndpointResolveDuration, value=PT0.000068S), MetricRecord(metric=ApiCallDuration, value=PT0.163802958S), MetricRecord(metric=CredentialsFetchDuration, value=PT0.145686542S), MetricRecord(metric=ServiceEndpoint, value=https://s3.amazonaws.com), MetricRecord(metric=ServiceId, value=S3)], children=[MetricCollection(name=ApiCallAttempt, metrics=[MetricRecord(metric=TimeToFirstByte, value=PT0.138816S), MetricRecord(metric=SigningDuration, value=PT0.007803459S), MetricRecord(metric=ReadThroughput, value=165153.96002660287), MetricRecord(metric=ServiceCallDuration, value=PT0.138816S), MetricRecord(metric=AwsExtendedRequestId, value=e13Swj3uwn0qP1Oz+m7II5OGq7jf8xxT8H18iDfRBCQmDg+gU4ek91Xrsl8XxRLROlIzCAPQtsQF0DAAWOb8ntuKCzX2AJdj), MetricRecord(metric=HttpStatusCode, value=200), MetricRecord(metric=BackoffDelayDuration, value=PT0S), MetricRecord(metric=TimeToLastByte, value=PT0.148915667S), MetricRecord(metric=AwsRequestId, value=78AW9BM7SWR6YMGB)], children=[MetricCollection(name=HttpClient, metrics=[MetricRecord(metric=MaxConcurrency, value=50), MetricRecord(metric=AvailableConcurrency, value=0), MetricRecord(metric=LeasedConcurrency, value=1), MetricRecord(metric=ConcurrencyAcquireDuration, value=PT0.002623S), MetricRecord(metric=PendingConcurrencyAcquires, value=0), MetricRecord(metric=HttpClientName, value=Apache)], children=[])])])
INFO  LoggingMetricPublisher - [4e6f2bb5] ApiCall
INFO  LoggingMetricPublisher - [4e6f2bb5] ┌──────────────────────────────────────────┐
INFO  LoggingMetricPublisher - [4e6f2bb5] │ MarshallingDuration=PT0.000063S          │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ RetryCount=0                             │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ ApiCallSuccessful=true                   │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ OperationName=ListBuckets                │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ EndpointResolveDuration=PT0.000024375S   │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ ApiCallDuration=PT0.018463083S           │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ CredentialsFetchDuration=PT0.000022334S  │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ ServiceEndpoint=https://s3.amazonaws.com │
INFO  LoggingMetricPublisher - [4e6f2bb5] │ ServiceId=S3                             │
INFO  LoggingMetricPublisher - [4e6f2bb5] └──────────────────────────────────────────┘
INFO  LoggingMetricPublisher - [4e6f2bb5]     ApiCallAttempt
INFO  LoggingMetricPublisher - [4e6f2bb5]     ┌───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ TimeToFirstByte=PT0.0165575S                                                                                          │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ SigningDuration=PT0.000301125S                                                                                        │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ ReadThroughput=1195591.792850103                                                                                      │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ ServiceCallDuration=PT0.0165575S                                                                                      │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ AwsExtendedRequestId=3QI1eenRuokdszWqZBmBMDUmko6FlSmHkM+CUMNMeLor7gJml4D4lv6QXUZ1zWoTgG+tHbr6yo2vHdz4h1P8PDovvtMFRCeB │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ HttpStatusCode=200                                                                                                    │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ BackoffDelayDuration=PT0S                                                                                             │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ TimeToLastByte=PT0.017952625S                                                                                         │
INFO  LoggingMetricPublisher - [4e6f2bb5]     │ AwsRequestId=78AVFAF795AAWAXH                                                                                         │
INFO  LoggingMetricPublisher - [4e6f2bb5]     └───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
INFO  LoggingMetricPublisher - [4e6f2bb5]         HttpClient
INFO  LoggingMetricPublisher - [4e6f2bb5]         ┌───────────────────────────────────────┐
INFO  LoggingMetricPublisher - [4e6f2bb5]         │ MaxConcurrency=50                     │
INFO  LoggingMetricPublisher - [4e6f2bb5]         │ AvailableConcurrency=0                │
INFO  LoggingMetricPublisher - [4e6f2bb5]         │ LeasedConcurrency=1                   │
INFO  LoggingMetricPublisher - [4e6f2bb5]         │ ConcurrencyAcquireDuration=PT0.00004S │
INFO  LoggingMetricPublisher - [4e6f2bb5]         │ PendingConcurrencyAcquires=0          │
INFO  LoggingMetricPublisher - [4e6f2bb5]         │ HttpClientName=Apache                 │
INFO  LoggingMetricPublisher - [4e6f2bb5]         └───────────────────────────────────────┘
INFO  S3LoggingMetricPublisherDemo - Found 6 buckets in your AWS account.
```

### Zusätzliche Artefakte für das Beispiel
<a name="logging-metric-publisher-complete-example-artifacts"></a>

Maven-Datei `pom.xml`

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>s3-logging-metric-publisher-demo</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>AWS S3 LoggingMetricPublisher Demo</name>
    <description>Demonstrates how to use LoggingMetricPublisher with AWS S3 SDK for Java 2.x</description>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <aws.java.sdk.version>2.31.66</aws.java.sdk.version>
        <log4j.version>2.24.3</log4j.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- AWS SDK BOM for dependency management -->
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.java.sdk.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- Log4j BOM for logging dependency management -->
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-bom</artifactId>
                <version>${log4j.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- AWS S3 SDK for demonstration -->
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
        </dependency>

        <!-- Log4j2 SLF4J implementation -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j2-impl</artifactId>
        </dependency>

        <!-- Log4j2 Core -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
```

`Log4j2.xml` Konfigurationsdatei

```
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </Console>
    </Appenders>
    <Loggers>
        <Root level="INFO">
            <AppenderRef ref="ConsoleAppender"/>
        </Root>
        <!-- Ensure LoggingMetricPublisher output appears. -->
        <Logger name="software.amazon.awssdk.metrics.LoggingMetricPublisher" level="INFO"/>
    </Loggers>
</Configuration>
```

Die Metriken umfassen Zeitinformationen, Servicedetails, Vorgangsnamen und HTTP-Statuscodes, die Ihnen helfen, die AWS API-Nutzungsmuster Ihrer Anwendung zu verstehen.

## Nächste Schritte
<a name="logging-metric-publisher-next-steps"></a>

Nach der Verwendung `LoggingMetricPublisher` für die Entwicklung und das Debuggen sollten Sie die folgenden Optionen für Produktionsumgebungen in Betracht ziehen:
+ Verwenden Sie für Anwendungen mit langer Laufzeit, [CloudWatchMetricPublisher](metric-pub-impl-cwmp.md)um Metriken CloudWatch zur Analyse und Benachrichtigung an Amazon zu senden
+ Verwenden Sie [EmfMetricLoggingPublisher](metric-pub-impl-emf.md)für AWS Lambda Funktionen die Veröffentlichung von Metriken im CloudWatch eingebetteten metrischen Format

# AWS SDK for Java 2.x: Umfassende Metrik-Referenz
<a name="metrics-list"></a>

Mit dem AWS SDK for Java 2.x können Sie Metriken von den Service-Clients in Ihrer Anwendung sammeln und diese Metriken dann auf [Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) veröffentlichen (ausgeben) CloudWatch.

In diesen Tabellen sind die Metriken, die Sie sammeln können, sowie alle Anforderungen für die Nutzung des HTTP-Clients aufgeführt.

Weitere Informationen zur Aktivierung und Konfiguration von Metriken für das SDK finden Sie unter [SDK-Metriken aktivieren](metrics.md).

## Bei jeder Anfrage gesammelte Metriken
<a name="metrics-perrequest"></a>


| Metrikname | Description | Typ | 
| --- | --- | --- | 
|  ApiCallDuration  |  Die Dauer des API-Aufrufs. Dies schließt alle unternommenen Anrufversuche ein.  |  Dauer\$1  | 
|  ApiCallSuccessful  |  Wahr, wenn der API-Aufruf erfolgreich war, andernfalls falsch.  |  Boolesch  | 
|  CredentialsFetchDuration  |  Die Zeitdauer, die benötigt wird, um die Signaturdaten für den API-Aufruf abzurufen.  |  Dauer\$1  | 
| EndpointResolveDuration | Die Dauer der Auflösung des Endpunkts, der für den API-Aufruf verwendet wurde. | Dauer\$1 | 
|  MarshallingDuration  |  Die Zeitdauer, die benötigt wird, um die SDK-Anfrage in eine HTTP-Anfrage umzuwandeln.  |  Dauer\$1  | 
|  OperationName  |  Der Name des aufgerufenen Dienstvorgangs.  |  Zeichenfolge  | 
|  RetryCount  |  Die Anzahl der Wiederholungen, die das SDK bei der Ausführung der Anforderung ausgeführt hat. 0 bedeutet, dass die Anfrage beim ersten Mal funktioniert hat und dass keine Wiederholungsversuche unternommen wurden. Weitere Hinweise zur Konfiguration des Wiederholungsverhaltens finden Sie unter. [Strategien für Wiederholungsversuche](retry-strategy.md#retry-strategies)  |  Ganzzahl  | 
|  ServiceId  |  Die eindeutige ID für den Dienst.  |  Zeichenfolge  | 
|  ServiceEndpoint  |  Der Endpunkt für den Dienst.  |  URI  | 
|  TokenFetchDuration  | Die Dauer des Abrufs der Signaturdaten für den API-Aufruf. | Dauer\$1 | 

[\$1 java.time.Duration.](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Duration.html)

## Für jeden Anforderungsversuch gesammelte Metriken
<a name="metrics-perattempt"></a>

Für jeden API-Aufruf sind möglicherweise mehrere Versuche erforderlich, bevor eine Antwort eingeht. Diese Metriken werden für jeden Versuch gesammelt.

### Kernmetriken
<a name="metrics-perattempt-core"></a>


| Metrikname | Description | Typ | 
| --- | --- | --- | 
|  AwsExtendedRequestId  |  Die erweiterte Anfrage-ID der Serviceanfrage.  |  Zeichenfolge  | 
|  AwsRequestId  |  Die Anforderungs-ID der Serviceanfrage.  |  Zeichenfolge  | 
|  BackoffDelayDuration  |  Die Dauer, während der das SDK auf diesen API-Aufrufversuch gewartet hat. Der Wert basiert auf dem auf dem Client `[https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/api/BackoffStrategy.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/retries/api/BackoffStrategy.html)` eingestellten Wert. Weitere Informationen finden Sie im [Strategien für Wiederholungsversuche](retry-strategy.md#retry-strategies) Abschnitt dieses Handbuchs.  |  Dauer\$1  | 
| ErrorType |  Die Art des Fehlers, der bei einem Anrufversuch aufgetreten ist. Folgende Werte sind möglich: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html)  | Zeichenfolge | 
| ReadThroughput |  Der Lesedurchsatz des Clients, definiert als. `NumberOfResponseBytesRead / (TTLB - TTFB)` Dieser Wert wird in Byte pro Sekunde angegeben. Beachten Sie, dass diese Metrik nur die Byte misst, die innerhalb von `ResponseTransformer` oder gelesen `AsyncResponseTransformer` werden. Daten, die außerhalb des Transformators gelesen werden — beispielsweise wenn der Antwortstream als Ergebnis des Transformators zurückgegeben wird — sind nicht in der Berechnung enthalten.  | Double | 
| WriteThroughput |  Der Schreibdurchsatz des Clients, definiert als. `RequestBytesWritten / (LastByteWrittenTime - FirstByteWrittenTime)` Dieser Wert wird in Byte pro Sekunde angegeben. Diese Metrik misst die Geschwindigkeit, mit der das SDK den Anforderungstext für den HTTP-Client bereitstellt. Sie schließt den Verbindungsaufbau, die TLS-Handshake-Zeit und die Serververarbeitungszeit aus. Diese Metrik wird nur für Anfragen gemeldet, die einen Streaming-Hauptteil wie S3 haben. PutObject Beachten Sie, dass diese Metrik die Pufferung auf der HTTP-Client-Ebene nicht berücksichtigt. Die tatsächliche Netzwerkübertragungsrate kann niedriger sein, wenn der HTTP-Client Daten vor dem Senden zwischenspeichert. Diese Metrik stellt eine Obergrenze des Netzwerkdurchsatzes dar.  | Double | 
|  ServiceCallDuration  |  Die Dauer, die benötigt wird, um eine Verbindung mit dem Dienst herzustellen (oder eine Verbindung vom Verbindungspool herzustellen), die serialisierte Anfrage zu senden und die erste Antwort zu empfangen (z. B. HTTP-Statuscode und Header). Dies beinhaltet NICHT die Zeit, die zum Lesen der gesamten Antwort vom Dienst benötigt wird.  |  Dauer\$1  | 
|  SigningDuration  |  Die Zeitdauer für das Signieren der HTTP-Anfrage.  |  Dauer\$1  | 
| TimeToFirstByte | Die Zeitspanne zwischen dem Senden der HTTP-Anfrage (einschließlich des Aufbaus einer Verbindung) an den Dienst und dem Empfangen des ersten Bytes der Header in der Antwort. | Dauer\$1 | 
| TimeToLastByte |  Die Zeitspanne zwischen dem Senden der HTTP-Anfrage (einschließlich des Aufbaus einer Verbindung) an den Dienst und dem Empfangen des letzten Bytes der Antwort. Beachten Sie, dass APIs sich diese Metrik bei zurückgesendeten Streaming-Antworten über die Zeit erstreckt, bis das `ResponseTransformer` Oder `AsyncResponseTransformer` abgeschlossen ist.  | Dauer\$1 | 
|  UnmarshallingDuration  |  Die Zeitdauer für das Unmarshalling der HTTP-Antwort auf eine SDK-Antwort. Hinweis: Bei Streaming-Vorgängen beinhaltet dies nicht die Zeit zum Lesen der Antwortnutzdaten.  |  Dauer\$1  | 

[\$1 java.time.Duration.](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Duration.html)

### HTTP-Metriken
<a name="metrics-perattempt-http"></a>


| Metrikname | Description | Typ | HTTP-Client erforderlich\$1 | 
| --- | --- | --- | --- | 
|  AvailableConcurrency  |  Die Anzahl zusätzlicher gleichzeitiger Anfragen, die der HTTP-Client unterstützt, ohne dass neue Verbindungen zum Zielserver hergestellt werden. Bei HTTP/1-Vorgängen entspricht dies der Anzahl der inaktiven TCP-Verbindungen, die mit dem Dienst eingerichtet wurden. Bei HTTP/2-Vorgängen entspricht dies der Anzahl der inaktiven Streams. Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus.  |  Ganzzahl  | Apache, Netty, CRT | 
|  ConcurrencyAcquireDuration  |  Die Zeitdauer, die benötigt wird, um einen Kanal aus dem Verbindungspool zu beziehen. Bei HTTP/1-Vorgängen entspricht ein Kanal einer TCP-Verbindung. Bei HTTP/2-Operationen entspricht ein Kanal einem HTTP/2-Stream-Kanal. Der Erwerb eines neuen Kanals kann Zeit beinhalten für: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html)  |  Dauer\$1  |  Apache, Netty, CRT  | 
|  HttpClientName  |  Der Name des für die Anfrage verwendeten HTTPs.  |  Zeichenfolge  |  Apache, Netty, CRT  | 
|  HttpStatusCode  |  Der Statuscode der HTTP-Antwort.  |  Ganzzahl  |  Beliebig  | 
|  LeasedConcurrency  |  Die Anzahl der Anfragen, die der HTTP-Client derzeit ausführt.  Bei HTTP/1-Vorgängen entspricht dies der Anzahl der aktiven TCP-Verbindungen mit dem Dienst (ohne inaktive Verbindungen). Bei HTTP/2-Vorgängen entspricht dies der Anzahl der aktiven HTTP-Streams mit dem Dienst (ohne Stream-Kapazität im Leerlauf).  Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus.  |  Ganzzahl  |  Apache, Netty, CRT  | 
|  LocalStreamWindowSize  |  Die lokale HTTP/2-Fenstergröße in Byte für den Stream, der diese Anforderung ausführt.  |  Ganzzahl  |  Netty  | 
|  MaxConcurrency  |  Die maximale Anzahl gleichzeitiger Anfragen, die der HTTP-Client unterstützt. Bei HTTP/1-Vorgängen entspricht dies der maximalen Anzahl von TCP-Verbindungen, die der HTTP-Client bündeln kann. Bei HTTP/2-Vorgängen entspricht dies der maximalen Anzahl von Streams, die der HTTP-Client bündeln kann. Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus.  |  Ganzzahl  |  Apache, Netty, CRT  | 
|  PendingConcurrencyAcquires  |  Die Anzahl der Anfragen, die auf Parallelität vom HTTP-Client warten. Bei HTTP/1-Vorgängen entspricht dies der Anzahl der Anfragen, die darauf warten, dass eine TCP-Verbindung hergestellt wird oder aus dem Verbindungspool zurückkehrt. Bei HTTP/2-Operationen entspricht dies der Anzahl der Anfragen, die auf einen neuen Stream (und möglicherweise eine neue HTTP/2-Verbindung) aus dem Verbindungspool warten. Hinweis: Dieser Wert variiert je nach Implementierung des HTTP-Clients: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sdk-for-java/latest/developer-guide/metrics-list.html) Der Wert ist auf eine einzelne HTTP-Clientinstanz beschränkt und schließt die Parallelität anderer HTTP-Clients in derselben JVM aus.  |  Ganzzahl  |  Apache, Netty, CRT  | 
|  RemoteStreamWindowSize  |  Die Größe des Remote-HTTP/2-Fensters in Byte für den Stream, der diese Anforderung ausführt.  |  Ganzzahl  |  Netty  | 

\$1 [java.time.Duration](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/time/Duration.html).

Die in der Spalte verwendeten Begriffe bedeuten:
+ Apache: der Apache-basierte HTTP-Client () `[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)`
+ Netty: der Netty-basierte HTTP-Client () `[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)`
+ CRT: der AWS CRT-basierte HTTP-Client () `[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)`
+ Beliebig: Die Erfassung von Metrikdaten hängt nicht vom HTTP-Client ab. Dazu gehört auch der URLConnection basierte HTTP-Client () `[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)`

# AWS SDK for Java 2.x Anwendungen überwachen
<a name="monitoring-overview"></a>

Die Überwachung ist ein wichtiger Bestandteil der Aufrechterhaltung der Zuverlässigkeit, Verfügbarkeit und Leistung von Anwendungen, die das AWS SDK for Java 2.x verwenden. AWS bietet die folgenden Überwachungstools, um das SDK for Java 2.x zu beobachten, zu melden, wenn etwas nicht stimmt, und gegebenenfalls automatische Maßnahmen zu ergreifen:
+ *Amazon CloudWatch* überwacht Ihre AWS Ressourcen und die Anwendungen, auf denen Sie laufen, AWS in Echtzeit. Sie können Kennzahlen erfassen und verfolgen, benutzerdefinierte Dashboards erstellen und Alarme festlegen, die Sie benachrichtigen oder Maßnahmen ergreifen, wenn eine bestimmte Metrik einen von Ihnen festgelegten Schwellenwert erreicht. Sie können beispielsweise die CPU-Auslastung oder andere Kennzahlen Ihrer EC2 Amazon-Instances CloudWatch verfolgen und bei Bedarf automatisch neue Instances starten. Weitere Informationen finden Sie im [ CloudWatch Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
+ Mit *Amazon CloudWatch Logs* können Sie Ihre Protokolldateien von EC2 Amazon-Instances und anderen Quellen überwachen CloudTrail, speichern und darauf zugreifen. CloudWatch Logs kann Informationen in den Protokolldateien überwachen und Sie benachrichtigen, wenn bestimmte Schwellenwerte erreicht werden. Sie können Ihre Protokolldaten auch in einem sehr robusten Speicher archivieren. Weitere Informationen finden Sie im [Amazon CloudWatch Logs-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).
+ *AWS CloudTrail*erfasst API-Aufrufe und zugehörige Ereignisse, die von oder im Namen Ihres AWS Kontos getätigt wurden, und übermittelt die Protokolldateien an einen von Ihnen angegebenen Amazon S3 S3-Bucket. Sie können feststellen, welche Benutzer und Konten angerufen wurden AWS, von welcher Quell-IP-Adresse aus die Anrufe getätigt wurden und wann die Aufrufe erfolgten. Weitere Informationen finden Sie im [AWS CloudTrail -Benutzerhandbuch](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

# Loggen mit dem SDK for Java 2.x
<a name="logging-slf4j"></a>

Das AWS SDK for Java 2.x verwendet [SLF4J](https://www.slf4j.org/manual.html), eine Abstraktionsschicht, die die Verwendung eines beliebigen von mehreren Protokollierungssystemen zur Laufzeit ermöglicht.

Zu den unterstützten Protokollierungssystemen gehören unter anderem das Java Logging Framework und Apache [Log4j 2.](https://logging.apache.org/log4j/2.x/) In diesem Thema erfahren Sie, wie Sie Log4j 2 als Protokollierungssystem für die Arbeit mit dem SDK verwenden.

## Log4j 2-Konfigurationsdatei
<a name="log4j-configuration-file"></a>

In der Regel verwenden Sie eine Konfigurationsdatei `log4j2.xml` mit dem Namen Log4j 2. Beispiel-Konfigurationsdateien werden nachfolgend angezeigt. Weitere Informationen über die Werte in der Konfigurationsdatei finden Sie im [Handbuch für die Log4j-Konfiguration](https://logging.apache.org/log4j/2.x/manual/configuration.html).

Die `log4j2.xml` Datei muss sich beim Start Ihrer Anwendung im Klassenpfad befinden. Für ein Maven-Projekt legen Sie die Datei in das Verzeichnis. `<project-dir>/src/main/resources`

Die `log4j2.xml` Konfigurationsdatei spezifiziert Eigenschaften wie die [Protokollierungsebene](https://logging.apache.org/log4j/2.x/manual/configuration.html#Loggers), an die die Protokollausgabe gesendet wird (z. B. [an eine Datei oder an die Konsole](https://logging.apache.org/log4j/2.x/manual/appenders.html)), und das [Format der Ausgabe](https://logging.apache.org/log4j/2.x/manual/layouts.html). Die Protokollierungsebene gibt den Detaillierungsgrad an, den Log4j 2 ausgibt. [https://logging.apache.org/log4j/2.x/manual/architecture.html#](https://logging.apache.org/log4j/2.x/manual/architecture.html#) Die Protokollierungsebene wird für jede Hierarchie separat festgelegt. Die Hauptprotokollierungshierarchie, die Sie mit dem verwenden, ist. AWS SDK for Java 2.x `software.amazon.awssdk`

## Protokollierungsabhängigkeit hinzufügen
<a name="sdk-java-logging-classpath"></a>

Verwenden Sie Folgendes, um die Log4J 2-Bindung für SLF4 J in Ihrer Build-Datei zu konfigurieren.

------
#### [ Maven ]

Fügen Sie Ihrer Datei die folgenden Elemente hinzu`pom.xml`.

```
...
<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-slf4j2-impl</artifactId>
   <version>VERSION</version>
</dependency>
...
```

------
#### [ Gradle–Kotlin DSL ]

Fügen Sie Ihrer `build.gradle.kts` Datei Folgendes hinzu.

```
...
dependencies {
    ...
    implementation("org.apache.logging.log4j:log4j-slf4j2-impl:VERSION")
    ...
}
...
```

------

Verwenden Sie `2.20.0` für die Mindestversion des `log4j-slf4j2-impl` Artefakts. Verwenden Sie für die neueste Version die in [Maven](https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-slf4j2-impl) Central veröffentlichte Version. Ersetzen Sie sie *VERSION* durch die Version, die Sie verwenden werden.

## SDK-spezifische Fehler und Warnungen
<a name="sdk-java-logging-service"></a>

Wir empfehlen, die Logger-Hierarchie von „software.amazon.awssdk“ immer auf „WARN“ gesetzt zu lassen, um wichtige Nachrichten aus den SDK-Clientbibliotheken abzufangen. Wenn der Amazon S3 S3-Client beispielsweise feststellt, dass Ihre Anwendung nicht ordnungsgemäß geschlossen wurde `InputStream` und möglicherweise Ressourcen verloren gehen, meldet der S3-Client dies in Form einer Warnmeldung an die Protokolle. Dadurch wird auch sichergestellt, dass Nachrichten protokolliert werden, wenn der Client Schwierigkeiten bei der Verarbeitung von Anforderungen oder Antworten hat.

In der folgenden `log4j2.xml` Datei wird das `rootLogger` auf „WARN“ gesetzt, was dazu führt, dass Warnmeldungen und Meldungen auf Fehlerebene von allen Loggern in der Anwendung ausgegeben werden, *einschließlich* der Logger in der Hierarchie „software.amazon.awssdk“. Alternativ können Sie die Logger-Hierarchie „software.amazon.awssdk“ explizit auf „WARN“ setzen, falls sie verwendet wird. `<Root level="ERROR">`

**Beispiel für eine Konfigurationsdatei Log4j2.xml**

Diese Konfiguration protokolliert Meldungen auf den Ebenen „ERROR“ und „WARN“ auf der Konsole für alle Logger-Hierarchien.

```
<Configuration status="WARN">
 <Appenders>
  <Console name="ConsoleAppender" target="SYSTEM_OUT">
   <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
  </Console>
 </Appenders>

 <Loggers>
  <Root level="WARN">
   <AppenderRef ref="ConsoleAppender"/>
  </Root>
 </Loggers>
</Configuration>
```

## Protokollierung der Zusammenfassung von Anforderungen/Antworten
<a name="sdk-java-logging-request-response"></a>

Jede Anfrage an eine AWS-Service generiert eine eindeutige AWS Anfrage-ID, die nützlich ist, wenn Sie auf ein Problem mit der Bearbeitung einer AWS-Service Anfrage stoßen. AWS Anfragen IDs sind programmgesteuert über [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/exception/SdkServiceException.html#requestId()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/exception/SdkServiceException.html#requestId())Objekte im SDK für jeden fehlgeschlagenen Serviceabruf zugänglich und können auch über die Protokollebene „DEBUG“ des Loggers „software.amazon.awssdk.request“ gemeldet werden.

Die folgende Datei bietet eine Zusammenfassung der Anfragen und Antworten. `log4j2.xml`

```
<Configuration status="WARN">
 <Appenders>
  <Console name="ConsoleAppender" target="SYSTEM_OUT">
   <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
  </Console>
 </Appenders>

 <Loggers>
  <Root level="ERROR">
   <AppenderRef ref="ConsoleAppender"/>
  </Root>
  <Logger name="software.amazon.awssdk" level="WARN" />
  <Logger name="software.amazon.awssdk.request" level="DEBUG" />
 </Loggers>
</Configuration>
```

Hier finden Sie ein Beispiel für die Protokollausgabe:

```
2022-09-23 16:02:08 [main] DEBUG software.amazon.awssdk.request:85 - Sending Request: DefaultSdkHttpFullRequest(httpMethod=POST, protocol=https, host=dynamodb.us-east-1.amazonaws.com, encodedPath=/, headers=[amz-sdk-invocation-id, Content-Length, Content-Type, User-Agent, X-Amz-Target], queryParameters=[])
2022-09-23 16:02:08 [main] DEBUG software.amazon.awssdk.request:85 - Received successful response: 200, Request ID: QS9DUMME2NHEDH8TGT9N5V53OJVV4KQNSO5AEMVJF66Q9ASUAAJG, Extended Request ID: not available
```

Wenn Sie nur an der Anfrage-ID interessiert sind, verwenden Sie`<Logger name="software.amazon.awssdk.requestId" level="DEBUG" />`.

## SDK-Protokollierung auf Debug-Ebene
<a name="sdk-debug-level-logging"></a>

Wenn Sie weitere Informationen darüber benötigen, was das SDK tut, können Sie die Protokollierungsebene des `software.amazon.awssdk` Loggers auf einstellen. `DEBUG` Auf dieser Ebene gibt das SDK eine große Menge an Details aus. Wir empfehlen daher, diese Stufe festzulegen, um Fehler mithilfe von Integrationstests zu beheben. 

Auf dieser Protokollierungsebene protokolliert das SDK Informationen zur Konfiguration, zur Auflösung von Anmeldeinformationen, zur Ausführung von Interceptoren, TLS-Aktivitäten auf hoher Ebene, zur Signierung von Anfragen und vieles mehr.

Im Folgenden finden Sie eine Auswahl von Anweisungen, die vom SDK auf `DEBUG` Ebene eines `S3Client#listBuckets()` Anrufs ausgegeben werden.

```
DEBUG s.a.a.r.p.AwsRegionProviderChain:57 - Unable to load region from software.amazon.awssdk.regions.providers.SystemSettingsRegionProvider@324dcd31:Unable to load region from system settings. Region must be specified either via environment variable (AWS_REGION) or  system property (aws.region).
DEBUG s.a.a.c.i.h.l.ClasspathSdkHttpServiceProvider:85 - The HTTP implementation loaded is software.amazon.awssdk.http.apache.ApacheSdkHttpService@a23a01d
DEBUG s.a.a.c.i.ExecutionInterceptorChain:85 - Creating an interceptor chain that will apply interceptors in the following order: [software.amazon.awssdk.core.internal.interceptor.HttpChecksumValidationInterceptor@69b2f8e5, software.amazon.awssdk.awscore.interceptor.HelpfulUnknownHostExceptionInterceptor@6331250e, software.amazon.awssdk.awscore.eventstream.EventStreamInitialRequestInterceptor@a10c1b5, software.amazon.awssdk.awscore.interceptor.TraceIdExecutionInterceptor@644abb8f, software.amazon.awssdk.services.s3.auth.scheme.internal.S3AuthSchemeInterceptor@1a411233, software.amazon.awssdk.services.s3.endpoints.internal.S3ResolveEndpointInterceptor@70325d20, software.amazon.awssdk.services.s3.endpoints.internal.S3RequestSetEndpointInterceptor@7c2327fa, software.amazon.awssdk.services.s3.internal.handlers.StreamingRequestInterceptor@4d847d32, software.amazon.awssdk.services.s3.internal.handlers.CreateBucketInterceptor@5f462e3b, software.amazon.awssdk.services.s3.internal.handlers.CreateMultipartUploadRequestInterceptor@3d7fa3ae, software.amazon.awssdk.services.s3.internal.handlers.DecodeUrlEncodedResponseInterceptor@58065f0c, software.amazon.awssdk.services.s3.internal.handlers.GetBucketPolicyInterceptor@3605c4d3, software.amazon.awssdk.services.s3.internal.handlers.S3ExpressChecksumInterceptor@585c13de, software.amazon.awssdk.services.s3.internal.handlers.AsyncChecksumValidationInterceptor@187eb9a8, software.amazon.awssdk.services.s3.internal.handlers.SyncChecksumValidationInterceptor@726a6b94, software.amazon.awssdk.services.s3.internal.handlers.EnableTrailingChecksumInterceptor@6ad11a56, software.amazon.awssdk.services.s3.internal.handlers.ExceptionTranslationInterceptor@522b2631, software.amazon.awssdk.services.s3.internal.handlers.GetObjectInterceptor@3ff57625, software.amazon.awssdk.services.s3.internal.handlers.CopySourceInterceptor@1ee29c84, software.amazon.awssdk.services.s3.internal.handlers.ObjectMetadataInterceptor@7c8326a4]
DEBUG s.a.a.u.c.CachedSupplier:85 - (SsoOidcTokenProvider()) Cached value is stale and will be refreshed.
...
DEBUG s.a.a.c.i.ExecutionInterceptorChain:85 - Creating an interceptor chain that will apply interceptors in the following order: [software.amazon.awssdk.core.internal.interceptor.HttpChecksumValidationInterceptor@51351f28, software.amazon.awssdk.awscore.interceptor.HelpfulUnknownHostExceptionInterceptor@21618fa7, software.amazon.awssdk.awscore.eventstream.EventStreamInitialRequestInterceptor@15f2eda3, software.amazon.awssdk.awscore.interceptor.TraceIdExecutionInterceptor@34cf294c, software.amazon.awssdk.services.sso.auth.scheme.internal.SsoAuthSchemeInterceptor@4d7aaca2, software.amazon.awssdk.services.sso.endpoints.internal.SsoResolveEndpointInterceptor@604b1e1d, software.amazon.awssdk.services.sso.endpoints.internal.SsoRequestSetEndpointInterceptor@62566842]
...
DEBUG s.a.a.request:85 - Sending Request: DefaultSdkHttpFullRequest(httpMethod=GET, protocol=https, host=portal.sso.us-east-1.amazonaws.com, encodedPath=/federation/credentials, headers=[amz-sdk-invocation-id, User-Agent, x-amz-sso_bearer_token], queryParameters=[role_name, account_id])
DEBUG s.a.a.c.i.h.p.s.SigningStage:85 - Using SelectedAuthScheme: smithy.api#noAuth
DEBUG s.a.a.h.a.i.c.SdkTlsSocketFactory:366 - Connecting socket to portal.sso.us-east-1.amazonaws.com/18.235.195.183:443 with timeout 2000
...
DEBUG s.a.a.requestId:85 - Received successful response: 200, Request ID: bb4f40f4-e920-4b5c-8648-58f26e7e08cd, Extended Request ID: not available
DEBUG s.a.a.request:85 - Received successful response: 200, Request ID: bb4f40f4-e920-4b5c-8648-58f26e7e08cd, Extended Request ID: not available
DEBUG s.a.a.u.c.CachedSupplier:85 - (software.amazon.awssdk.services.sso.auth.SsoCredentialsProvider@b965857) Successfully refreshed cached value. Next Prefetch Time: 2024-04-25T22:03:10.097Z. Next Stale Time: 2024-04-25T22:05:30Z
DEBUG s.a.a.c.i.ExecutionInterceptorChain:85 - Interceptor 'software.amazon.awssdk.services.s3.endpoints.internal.S3RequestSetEndpointInterceptor@7c2327fa' modified the message with its modifyHttpRequest method.
...
DEBUG s.a.a.c.i.h.p.s.SigningStage:85 - Using SelectedAuthScheme: aws.auth#sigv4
...
DEBUG s.a.a.a.s.Aws4Signer:85 - AWS4 Canonical Request: GET
...
DEBUG s.a.a.h.a.a.i.s.DefaultV4RequestSigner:85 - AWS4 String to sign: AWS4-HMAC-SHA256
20240425T210631Z
20240425/us-east-1/s3/aws4_request
aafb7784627fa7a49584256cb746279751c48c2076f813259ef767ecce304d64
DEBUG s.a.a.h.a.i.c.SdkTlsSocketFactory:366 - Connecting socket to s3.us-east-1.amazonaws.com/52.217.41.86:443 with timeout 2000
...
```

Die folgende `log4j2.xml` Datei konfiguriert die vorherige Ausgabe.

```
<Configuration status="WARN">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT">
            <PatternLayout pattern="%-5p %c{1.}:%L - %m%n" />
        </Console>
    </Appenders>

    <Loggers>
        <Root level="WARN">
            <AppenderRef ref="ConsoleAppender"/>
        </Root>
        <Logger name="software.amazon.awssdk" level="DEBUG" />
    </Loggers>
</Configuration>
```

## Aktivieren Sie die Kabelprotokollierung
<a name="sdk-java-logging-verbose"></a>

Es kann nützlich sein, die genauen Anfragen und Antworten zu sehen, die das SDK for Java 2.x sendet und empfängt. Wenn Sie Zugriff auf diese Informationen benötigen, können Sie sie vorübergehend aktivieren, indem Sie je nach dem vom Service-Client verwendeten HTTP-Client die erforderliche Konfiguration hinzufügen.

Standardmäßig verwenden synchrone Dienstclients, wie der [S3Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html), einen zugrunde liegenden Apache, und asynchrone Dienstclients HttpClient, wie der [S3 AsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html), verwenden einen nicht blockierenden Netty-HTTP-Client.

Im Folgenden finden Sie eine Aufschlüsselung der HTTP-Clients, die Sie für die beiden Kategorien von Service-Clients verwenden können:


| Synchrone HTTP-Clients | Asynchrone HTTP-Clients | 
| --- | --- | 
| [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) (Standard) | [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) (Standard) | 
| [UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html) | [AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html) | 
| [AwsCrtHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtHttpClient.html) |  | 
| [Apache 5 HttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache5/Apache5HttpClient.html)  | 

Auf der entsprechenden Registerkarte unten finden Sie die Konfigurationseinstellungen, die Sie je nach dem zugrunde liegenden HTTP-Client hinzufügen müssen.

**Warnung**  
Wir empfehlen Ihnen, die Übertragungsprotokollierung ausschließlich für Debugging-Zwecke zu verwenden. Deaktivieren Sie sie in Produktionsumgebungen, da sie sensible Daten aufzeichnen kann. Sie protokolliert die gesamte Anfrage oder Antwort ohne Verschlüsselung, auch bei einem HTTPS-Aufruf. Bei umfangreichen Anfragen (z. B. zum Hochladen einer Datei Amazon S3) oder Antworten kann die ausführliche Kabelprotokollierung auch die Leistung Ihrer Anwendung erheblich beeinträchtigen.

------
#### [ ApacheHttpClient ]

Fügen Sie der `log4j2.xml` Konfigurationsdatei den Logger „org.apache.http.wire“ hinzu und setzen Sie den Level auf „DEBUG“.

Die folgende `log4j2.xml` Datei aktiviert das Full-Wire-Logging für den Apache. HttpClient

```
<Configuration status="WARN">
 <Appenders>
  <Console name="ConsoleAppender" target="SYSTEM_OUT">
   <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
  </Console>
 </Appenders>

 <Loggers>
  <Root level="WARN">
   <AppenderRef ref="ConsoleAppender"/>
  </Root>
  <Logger name="software.amazon.awssdk" level="WARN" />
  <Logger name="software.amazon.awssdk.request" level="DEBUG" />
  <Logger name="org.apache.http.wire" level="DEBUG" />
 </Loggers>
</Configuration>
```

Für das Wire Logging mit Apache ist eine zusätzliche Maven-Abhängigkeit vom `log4j-1.2-api` Artefakt erforderlich, da 1.2 unter der Haube verwendet wird. 

Der vollständige Satz der Maven-Abhängigkeiten für log4j 2, einschließlich der Drahtprotokollierung für den Apache HTTP-Client, ist in den folgenden Ausschnitten aus der Build-Datei dargestellt.

**Maven**

```
...
<dependencyManagement>
    ...
    <dependencies>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-bom</artifactId>
            <version>VERSION</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
     </dependencies>
</dependencyManagement>
...
<!-- The following is needed for Log4j2 with SLF4J -->
<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-slf4j2-impl</artifactId>
</dependency>

<!-- The following is needed for Apache HttpClient wire logging -->
<dependency>
   <groupId>org.apache.logging.log4j</groupId>
   <artifactId>log4j-1.2-api</artifactId>
</dependency>
...
```

**Gradle-Kotlin DSL**

```
...
dependencies {
    ...
    implementation(platform("org.apache.logging.log4j:log4j-bom:VERSION"))
    implementation("org.apache.logging.log4j:log4j-slf4j2-impl")
    implementation("org.apache.logging.log4j:log4j-1.2-api")
}
...
```

Wird `2.20.0` für die Mindestversion des Artefakts verwendet. `log4j-bom` Verwenden Sie für die neueste Version die in [Maven](https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-bom) Central veröffentlichte Version. Ersetzen Sie sie *VERSION* durch die Version, die Sie verwenden werden.

------
#### [ Apache5HttpClient ]

Fügen Sie den Logger „org.apache.hc.client5.http.wire“ zur Konfigurationsdatei hinzu und setzen Sie den `log4j2.xml` Level auf „DEBUG“.

Die folgende Datei aktiviert das Full-Wire-Logging für den Apache5. `log4j2.xml` HttpClient

```
<Configuration status="WARN">
 <Appenders>
  <Console name="ConsoleAppender" target="SYSTEM_OUT">
   <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
  </Console>
 </Appenders>

 <Loggers>
  <Root level="WARN">
   <AppenderRef ref="ConsoleAppender"/>
  </Root>
  <Logger name="software.amazon.awssdk" level="WARN" />
  <Logger name="software.amazon.awssdk.request" level="DEBUG" />
  <Logger name="org.apache.hc.client5.http.wire" level="DEBUG" />
 </Loggers>
</Configuration>
```

------
#### [ UrlConnectionHttpClient ]

Um Details für Service-Clients zu protokollieren, die das verwenden`UrlConnectionHttpClient`, erstellen Sie zunächst eine `logging.properties` Datei mit dem folgenden Inhalt:

```
handlers=java.util.logging.ConsoleHandler
java.util.logging.ConsoleHandler.level=FINEST
sun.net.www.protocol.http.HttpURLConnection.level=ALL
```

Stellen Sie die folgende JVM-Systemeigenschaft mit dem vollständigen Pfad von ein: `logging.properties`

```
-Djava.util.logging.config.file=/full/path/to/logging.properties
```

Diese Konfiguration protokolliert nur die Header der Anfrage und Antwort, zum Beispiel:

```
<Request>  FINE: sun.net.www.MessageHeader@35a9782c11 pairs: {GET /fileuploadtest HTTP/1.1: null}{amz-sdk-invocation-id: 5f7e707e-4ac5-bef5-ba62-00d71034ffdc}{amz-sdk-request: attempt=1; max=4}{Authorization: AWS4-HMAC-SHA256 Credential=<deleted>/20220927/us-east-1/s3/aws4_request, SignedHeaders=amz-sdk-invocation-id;amz-sdk-request;host;x-amz-content-sha256;x-amz-date;x-amz-te, Signature=e367fa0bc217a6a65675bb743e1280cf12fbe8d566196a816d948fdf0b42ca1a}{User-Agent: aws-sdk-java/2.17.230 Mac_OS_X/12.5 OpenJDK_64-Bit_Server_VM/25.332-b08 Java/1.8.0_332 vendor/Amazon.com_Inc. io/sync http/UrlConnection cfg/retry-mode/legacy}{x-amz-content-sha256: UNSIGNED-PAYLOAD}{X-Amz-Date: 20220927T133955Z}{x-amz-te: append-md5}{Host: tkhill-test1.s3.amazonaws.com}{Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2}{Connection: keep-alive}
<Response> FINE: sun.net.www.MessageHeader@70a36a6611 pairs: {null: HTTP/1.1 200 OK}{x-amz-id-2: sAFeZDOKdUMsBbkdjyDZw7P0oocb4C9KbiuzfJ6TWKQsGXHM/dFuOvr2tUb7Y1wEHGdJ3DSIxq0=}{x-amz-request-id: P9QW9SMZ97FKZ9X7}{Date: Tue, 27 Sep 2022 13:39:57 GMT}{Last-Modified: Tue, 13 Sep 2022 14:38:12 GMT}{ETag: "2cbe5ad4a064cedec33b452bebf48032"}{x-amz-transfer-encoding: append-md5}{Accept-Ranges: bytes}{Content-Type: text/plain}{Server: AmazonS3}{Content-Length: 67}
```

Um die request/response Textkörper zu sehen, fügen Sie `-Djavax.net.debug=all` sie den JVM-Eigenschaften hinzu. Diese zusätzliche Eigenschaft protokolliert eine Vielzahl von Informationen, einschließlich aller SSL-Informationen. 

Suchen Sie in der Protokollkonsole oder der Protokolldatei nach dem Abschnitt des Protokolls, der die tatsächlichen Anfragen und Antworten enthält, `"GET"` oder `"POST"` wechseln Sie schnell zu diesem Abschnitt. `"Plaintext before ENCRYPTION"`Suchen Sie nach Anfragen und `"Plaintext after DECRYPTION"` Antworten, um den vollständigen Text der Überschriften und Textteile zu sehen.

------
#### [ NettyNioAsyncHttpClient ]

Wenn Ihr asynchroner Service-Client den Standard verwendet`NettyNioAsyncHttpClient`, fügen Sie Ihrer `log4j2.xml` Datei zwei zusätzliche Logger hinzu, um HTTP-Header und Anforderungs-/Antworttexte zu protokollieren.

```
<Logger name="io.netty.handler.logging" level="DEBUG" />
<Logger name="io.netty.handler.codec.http2.Http2FrameLogger" level="DEBUG" />
```

Hier ist ein vollständiges Beispiel: `log4j2.xml`

```
<Configuration status="WARN">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
        </Console>
    </Appenders>

    <Loggers>
        <Root level="WARN">
            <AppenderRef ref="ConsoleAppender"/>
        </Root>
        <Logger name="software.amazon.awssdk" level="WARN" />
        <Logger name="software.amazon.awssdk.request" level="DEBUG" />
        <Logger name="io.netty.handler.logging" level="DEBUG" />
        <Logger name="io.netty.handler.codec.http2.Http2FrameLogger" level="DEBUG" />
    </Loggers>
</Configuration>
```

Diese Einstellungen protokollieren alle Header-Details und request/response Textkörper.

------
#### [ AwsCrtAsyncHttpClient/AwsCrtHttpClient ]

Wenn Sie Ihren Service-Client so konfiguriert haben, dass er eine Instanz eines AWS CRT-basierten HTTP-Clients verwendet, können Sie Details protokollieren, indem Sie die JVM-Systemeigenschaften festlegen oder programmgesteuert.


|  | 
| --- |
|  Log to a file at "Debug" level  | 
|  Mithilfe von Systemeigenschaften: <pre>-Daws.crt.log.level=Trace <br />-Daws.crt.log.destination=File <br />-Daws.crt.log.filename=<path to file></pre>  |  Programmgesteuert: <pre>import software.amazon.awssdk.crt.Log;<br /><br />// Execute this statement before constructing the SDK service client.<br />Log.initLoggingToFile(Log.LogLevel.Trace, "<path to file>");</pre>  | 
|  Log to the console at "Debug" level  | 
|  Systemeigenschaften verwenden: <pre>-Daws.crt.log.level=Trace <br />-Daws.crt.log.destination=Stdout</pre>  |  Programmgesteuert: <pre>import software.amazon.awssdk.crt.Log;<br /><br />// Execute this statement before constructing the SDK service client.<br />Log.initLoggingToStdout(Log.LogLevel.Trace);</pre>  | 

Aus Sicherheitsgründen protokollieren die AWS CRT-basierten HTTP-Clients auf der „Trace“ -Ebene nur Antwortheader. Anforderungsheader, Anforderungstexte und Antworttexte werden nicht protokolliert.

------