As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configurando recursos de observabilidade no AWS SDK for Java 2.x
<a name="observability"></a>

A telemetria é a coleta e transmissão automatizadas de dados de fontes remotas que permitem monitorar e analisar o comportamento do sistema. 

A observabilidade no SDK for Java 2.x fornece aos desenvolvedores uma visão abrangente sobre como seus aplicativos Java interagem Serviços da AWS por meio de dados avançados de telemetria que capturam o ciclo de vida completo da solicitação. Esses recursos permitem que você colete, analise e visualize sinais de telemetria, como métricas, registros e rastreamentos, permitindo monitorar padrões de solicitação, identificar gargalos e otimizar as AWS interações do seu aplicativo para melhorar a confiabilidade e o desempenho.

**Topics**
+ [Metrics](metrics.md)
+ [Monitoramento](monitoring-overview.md)
+ [Registro em log](logging-slf4j.md)

# Publique métricas do SDK a partir do AWS SDK for Java 2.x
<a name="metrics"></a>

Com isso, AWS SDK for Java 2.x você pode coletar métricas sobre os clientes de serviços e solicitações em seu aplicativo, analisar a saída no Amazon CloudWatch Logs e, em seguida, agir de acordo com ela.

Por padrão, a coleta de métricas está desativada no SDK. Este tópico ajuda a habilitar e configurá-lo.

## Conceitos básicos das métricas de SDK
<a name="getting-started-with-metrics"></a>

Para habilitar a coleta de métricas na aplicação, escolha a implementação apropriada da interface `[MetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/MetricPublisher.html)` com base no seu caso de uso e siga as instruções detalhadas de configuração:

**Para aplicações de longa execução:**
+ Usar o `[CloudWatchMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/cloudwatch/CloudWatchMetricPublisher.html)`
+ Consulte instruções completas de configuração, exemplos de código e opções de configuração em [Publicar métricas do SDK de aplicações de longa execução](metric-pub-impl-cwmp.md).

**Para AWS Lambda funções:**
+ Usar o `[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)`
+ Consulte [Publicar métricas do SDK para AWS Lambda funções para](metric-pub-impl-emf.md) obter instruções completas de configuração, dependências e configurações específicas do Lambda.

**Para solução de problemas e saída do console:**
+ Usar o `[LoggingMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/LoggingMetricPublisher.html)`
+ Consulte instruções de configuração, opções de formatação e exemplos de desenvolvimento e solução de problemas locais em [Exibir métricas do SDK no console para desenvolvimento e depuração](metric-pub-impl-logging.md).

## Pré-visualização da implementação rápida
<a name="quick-implementation-preview"></a>

Veja como é a ativação de métricas para cada caso de uso:

**Aplicações de longa execução:**

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

**Funções do Lambda:**

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

**Desenvolvimento e depuração:**

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

## Limitação de métricas do cliente AWS S3 baseado em CRT
<a name="metrics-using-s3-crt-based-client"></a>

Atualmente, o [Cliente do S3 baseado no AWS CRT](crt-based-s3-client.md) não permite a coleta de métricas do SDK. O construtor de uma instância de cliente S3 AWS baseada em CRT, [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), não fornece métodos para configurar editores de métricas.

## Quando as métricas estão disponíveis?
<a name="when-are-metrics-available"></a>

As métricas geralmente ficam disponíveis em 5 a 10 minutos após a emissão das métricas pelo SDK para Java. Para obter up-to-date métricas precisas, verifique o Cloudwatch pelo menos 10 minutos depois de emitir as métricas de seus aplicativos Java. 

## Quais informações são coletadas?
<a name="what-information-is-collected"></a>

A coleção de métricas inclui o seguinte:
+ Número de solicitações de API, incluindo se foram bem-sucedidas ou se falharam
+ Informações sobre o Serviços da AWS que você chama em suas solicitações de API, incluindo exceções retornadas
+ A duração de várias operações, como marshalling, assinatura e solicitações HTTP
+ Métricas do cliente HTTP, como o número de conexões abertas, o número de solicitações pendentes e o nome do cliente HTTP usado

**nota**  
As métricas disponíveis variam de acordo com o cliente HTTP.

Para obter uma lista completa, consulte [Métricas de serviço do cliente](metrics-list.md).

## Como posso usar essas informações?
<a name="how-can-i-use-this-information"></a>

Use as métricas que o SDK coleta para monitorar os clientes de serviço em sua aplicação. Você pode analisar as tendências gerais de uso, identificar anomalias, analisar as exceções retornadas pelos clientes de serviço ou obter mais informações para entender um problema específico. Usando o Amazon CloudWatch Logs, você também pode criar alarmes para notificá-lo assim que seu aplicativo atingir uma condição definida por você.

Para obter mais informações, consulte Como [usar métricas do Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) e [Usar alarmes do Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) no [Guia do usuário do Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).

# Publique métricas do SDK de aplicativos de longa execução usando o AWS SDK for Java 2.x
<a name="metric-pub-impl-cwmp"></a>

Como a `[CloudWatchMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/cloudwatch/CloudWatchMetricPublisher.html)` implementação agrega e carrega periodicamente métricas para a Amazon CloudWatch com um atraso, seu uso é mais adequado para aplicativos de longa execução. 

As configurações padrão do editor de métricas têm como objetivo minimizar o uso e o CloudWatch custo da memória, ao mesmo tempo em que fornecem uma quantidade útil de informações sobre os dados métricos.

## Configuração
<a name="prerequisitesmetrics"></a>

Antes de ativar e usar as métricas usando `CloudWatchMetricPublisher`, siga as etapas a seguir.

### Etapa 1: adicionar dependência necessária
<a name="cwmp-set-up-deps"></a>

Configure as dependências do seu projeto (por exemplo, no seu arquivo `pom.xml` ou `build.gradle`) para usar a versão `2.14.0` ou posterior do AWS SDK para Java.

Inclua o artifactId `cloudwatch-metric-publisher` com o número da versão `2.14.0` ou posterior nas dependências do projeto.

Por exemplo:

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

### Etapa 2: configurar as permissões necessárias
<a name="cwmp-set-up-perms"></a>

Habilite as permissões `cloudwatch:PutMetricData` para a identidade do IAM usada pelo publicador de métricas para permitir que o SDK para Java escreva métricas.

## Habilitar métricas para uma solicitação específica
<a name="enable-metrics-for-a-specific-request"></a>

A classe a seguir mostra como habilitar o editor de CloudWatch métricas para uma solicitação ao Amazon DynamoDB. Ele usa a configuração padrão do publicador de métricas.

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

**Importante**  
A aplicação deve chamar `close` na instância `[MetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/MetricPublisher.html)` quando o cliente de serviço não estiver mais em uso. Não fazer isso pode causar vazamentos de threads ou descritores de arquivo.

## Habilitar métricas resumidas para um cliente de serviço específico
<a name="enable-metrics-for-a-specific-service-client"></a>

O trecho de código a seguir mostra como habilitar um editor de CloudWatch métricas com configurações padrão para um cliente de serviço.

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

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

## Personalize um editor de CloudWatch métricas
<a name="customize-metrics-publisher"></a>

A classe a seguir demonstra como definir uma configuração personalizada para o publicador de métricas de um cliente de serviço específico. As personalizações incluem carregar um perfil específico, especificar uma AWS região para a qual o editor de métricas envia solicitações e personalizar a frequência com que o editor envia métricas. 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();
    }
}
```

As personalizações mostradas no trecho anterior têm os efeitos a seguir.
+ O `cloudWatchClient` método permite que você personalize o CloudWatch cliente usado para enviar métricas. Neste exemplo, usamos uma região diferente do padrão de *us-east-1* para onde o cliente envia métricas. Também usamos um perfil nomeado diferente, *cloudwatch*, cujas credenciais serão usadas para autenticar solicitações para. CloudWatch Essas credenciais devem ter permissões para `cloudwatch:PutMetricData`.
+ O `uploadFrequency` método permite que você especifique com que frequência o editor de métricas faz o upload das métricas. CloudWatch O padrão é uma vez por minuto.
+ O método `maximumCallsPerUpload` limita o número de chamadas feitas por upload. O valor padrão é ilimitado.
+ Por padrão, o SDK para Java 2.x publica métricas no namespace `AwsSdk/JavaSdk2`. Você pode usar o método `namespace` para especificar um valor diferente.
+ Por padrão, o SDK publica métricas resumidas. As métricas resumidas consistem em média, mínimo, máximo, soma e contagem de amostras. Ao especificar uma ou mais métricas do SDK no método `detailedMetrics`, o SDK publica dados adicionais para cada métrica. Esses dados adicionais permitem estatísticas percentuais, como p90 e p99, que você pode consultar. CloudWatch As métricas detalhadas são especialmente úteis para métricas de latência`APICallDuration`, como a que mede a end-to-end latência das solicitações de clientes do SDK. É possível usar os campos da classe `[CoreMetric](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/metrics/CoreMetric.html)` para especificar outras métricas comuns do SDK. 

**Próximas etapas:** Se você também estiver trabalhando com funções do Lambda, consulte [Publicar métricas do SDK para AWS Lambda funções para publicação de métricas baseadas](metric-pub-impl-emf.md) em EMF.

# Publique métricas do SDK para AWS Lambda funções usando o AWS SDK for Java 2.x
<a name="metric-pub-impl-emf"></a>

Como as funções do Lambda normalmente são executadas de milissegundos a minutos, qualquer atraso no envio das métricas, o que acontece com `CloudWatchMetricPublisher`, apresenta o risco de perda de dados. 

`[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)`fornece uma abordagem mais adequada ao escrever imediatamente métricas como entradas de registro estruturadas em [CloudWatch Embedded Metric Format (EMF)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format.html). `EmfMetricLoggingPublisher`funciona em ambientes de execução que têm integração integrada com o Amazon CloudWatch Logs, como AWS Lambda o Amazon Elastic Container Service.

## Configuração
<a name="metric-pub-impl-emf-set-up"></a>

Antes de ativar e usar as métricas usando `EmfMetricLoggingPublisher`, siga as etapas a seguir.

### Etapa 1: adicionar dependência necessária
<a name="metric-pub-impl-emf-set-up-deps"></a>

Configure as dependências do seu projeto (por exemplo, no seu arquivo `pom.xml` ou `build.gradle`) para usar a versão `2.30.3` ou posterior do AWS SDK para Java.

Inclua o artifactId `emf-metric-logging-publisher` com o número da versão `2.30.3` ou posterior nas dependências do projeto.

Por exemplo:

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

### Etapa 2: configurar as permissões necessárias
<a name="metric-pub-impl-emf-set-up-perm"></a>

Habilite as permissões `logs:PutLogEvents` para a identidade do IAM usada pelo publicador de métricas para permitir que o SDK para Java escreva logs formatados em EMF.

### Etapa 3: configurar logs
<a name="metric-pub-impl-emf-set-up-logger"></a>

Para garantir a coleta adequada de métricas, configure o envio dos logs ao console no nível de `INFO` ou inferior (como `DEBUG`). No arquivo `log4j2.xml`:

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

Consulte mais informações sobre como configurar um arquivo `log4j2.xml` no [tópico de logs](logging-slf4j.md) deste guia. 

## Configurar e usar `EmfMetricLoggingPublisher`
<a name="metric-pub-impl-emf-use"></a>

A seguinte classe de função do Lambda primeiro cria e configura uma instância `EmfMetricLoggingPublisher` e depois a usa com um cliente de serviço do Amazon DynamoDB:

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

Quando o cliente do DynamoDB executa `putItem` o método, ele publica automaticamente as métricas em CloudWatch um stream de log no formato EMF. 

### Exemplo de um evento de logs em EMF
<a name="emf-logged-output"></a>

Por exemplo, se você enviar o seguinte evento para a função GameHandler Lambda com o registro configurado conforme mostrado anteriormente:

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

Depois que a função processa o evento, você encontra dois eventos de log semelhantes ao exemplo a seguir. O objeto JSON no segundo evento contém os dados de métricas do Java SDK para a operação `PutItem` no DynamoDB.

Quando CloudWatch recebe um evento de log no formato EMF, ele analisa automaticamente o JSON estruturado para extrair dados métricos. CloudWatch em seguida, cria métricas correspondentes enquanto armazena a entrada de registro original em 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
}
```

A [documentação da API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.Builder.html) referente a `EmfMetricLoggingPublisher.Builder` mostra as opções de configuração que você pode usar.

Você também pode ativar o registro de métricas EMF para uma única solicitação, conforme [mostrado no CloudWatchMetricPublisher](metric-pub-impl-cwmp.md#enable-metrics-for-a-specific-request).

**Próximas etapas:** Para aplicativos de longa execução, consulte [Publicar métricas do SDK de aplicativos de longa execução](metric-pub-impl-cwmp.md) para publicação de métricas CloudWatch baseadas.

# Envie métricas do SDK para o console usando o AWS SDK for Java 2.x
<a name="metric-pub-impl-logging"></a>

A implementação `[LoggingMetricPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/LoggingMetricPublisher.html)` gera métricas diretamente no console ou nos arquivos de log da aplicação. Essa abordagem é ideal para desenvolvimento, depuração e compreensão de quais métricas o SDK coleta sem exigir serviços externos, como a Amazon. CloudWatch

Ao contrário de `CloudWatchMetricPublisher` e `EmfMetricLoggingPublisher`, `LoggingMetricPublisher` fornece uma saída imediata sem atrasos ou dependências externas. Isso o torna perfeito para cenários de desenvolvimento local e solução de problemas.

## Quando usar LoggingMetricPublisher
<a name="logging-metric-publisher-when-to-use"></a>

Use `LoggingMetricPublisher` quando precisar:
+ Depurar a coleta de métricas durante o desenvolvimento
+ Entender quais métricas o SDK coleta para as operações
+ Solucionar problemas de desempenho localmente
+ Testar a coleta de métricas sem dependências de serviços externos
+ Visualizar as métricas imediatamente em seu console ou em arquivos de log

**nota**  
`LoggingMetricPublisher` não é recomendado para ambientes de produção em que você precisa de recursos persistentes de armazenamento e análise de métricas.

## Configurar logs do console para métricas
<a name="logging-metric-publisher-setup"></a>

Para ver a saída `LoggingMetricPublisher`, configure o framework de logs para exibir mensagens de nível `INFO`. A configuração `log4j2.xml` a seguir garante que as métricas apareçam no console:

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

Essa configuração orienta o SDK a gerar métricas para o console no nível `INFO`. A configuração do logger `LoggingMetricPublisher` garante que a saída métrica apareça mesmo se o logger raiz usar um nível mais alto, como `WARN` ou `ERROR`.

## Habilitar métricas de console para um cliente de serviço
<a name="logging-metric-publisher-basic-usage"></a>

O exemplo a seguir mostra como criar um `LoggingMetricPublisher` e usá-lo com um cliente do Amazon Simple Storage Service:

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

## Escolher o formato de saída da métrica
<a name="logging-metric-publisher-formatting-options"></a>

O `LoggingMetricPublisher` permite dois formatos de saída:
+ **Formato PLAIN (padrão):** gera métricas como entradas compactas de linha única
+ **Formato PRETTY:** gera métricas em um formato de várias linhas, legível para humanos

O exemplo a seguir mostra como usar o formato PRETTY para facilitar a leitura durante o desenvolvimento:

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

## Exemplo completo
<a name="logging-metric-publisher-complete-example"></a>

O exemplo a seguir demonstra o uso de `LoggingMetricPublisher` de duas maneiras:
+ No nível de cliente de serviço
+ Para uma única solicitação

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

O código registra o seguinte no console:

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

### Artefatos adicionais para o exemplo
<a name="logging-metric-publisher-complete-example-artifacts"></a>

Arquivo `pom.xml` do Maven

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

Arquivo de configuração `Log4j2.xml`

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

As métricas incluem informações de tempo, detalhes do serviço, nomes das operações e códigos de status HTTP que ajudam você a entender os padrões de uso da AWS API do seu aplicativo.

## Próximas etapas
<a name="logging-metric-publisher-next-steps"></a>

Depois de usar `LoggingMetricPublisher` para desenvolvimento e depuração, considere estas opções para ambientes de produção:
+ Para aplicativos de longa duração, use [CloudWatchMetricPublisher](metric-pub-impl-cwmp.md)para enviar métricas à Amazon CloudWatch para análise e alertas
+ Para AWS Lambda funções, use [EmfMetricLoggingPublisher](metric-pub-impl-emf.md)para publicar métricas no formato métrico CloudWatch incorporado

# AWS SDK for Java 2.x: referência abrangente de métricas
<a name="metrics-list"></a>

Com o AWS SDK for Java 2.x, você pode coletar métricas dos clientes de serviço em seu aplicativo e depois publicar (gerar) essas métricas [na Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html).

Essas tabelas listam as métricas que é possível coletar e os requisitos de uso do cliente HTTP.

Para obter mais informações sobre como habilitar e configurar métricas para o SDK, consulte [Como habilitar métricas do SDK](metrics.md).

## Métricas coletadas com cada solicitação
<a name="metrics-perrequest"></a>


| Nome da métrica | Description | Tipo | 
| --- | --- | --- | 
|  ApiCallDuration  |  A duração da chamada de API. Isso inclui todas as tentativas de chamada feitas.  |  Duração\$1  | 
|  ApiCallSuccessful  |  Verdadeiro se a chamada de API foi bem-sucedida, falso se não foi.  |  Booleano  | 
|  CredentialsFetchDuration  |  O tempo necessário para obter as credenciais de assinatura para a chamada de API.  |  Duração\$1  | 
| EndpointResolveDuration | A duração do tempo para resolver o endpoint usado na chamada de API. | Duração\$1 | 
|  MarshallingDuration  |  O tempo necessário para converter a solicitação de SDK em uma solicitação HTTP.  |  Duração\$1  | 
|  OperationName  |  O nome da operação de serviço que está sendo invocada.  |  String  | 
|  RetryCount  |  O número de novas tentativas que o SDK realizou na execução da solicitação. 0 indica que a solicitação funcionou na primeira vez e que nenhuma tentativa foi feita. Consulte mais informações sobre como configurar a retenção de dados em [Estratégias de novas tentativas](retry-strategy.md#retry-strategies).  |  Inteiro  | 
|  ServiceId  |  O ID exclusivo para o serviço.  |  String  | 
|  ServiceEndpoint  |  O endpoint para o serviço.  |  URI  | 
|  TokenFetchDuration  | O tempo necessário para obter as credenciais de assinatura para a chamada de API. | Duração\$1 | 

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

## Métricas coletadas para cada tentativa de solicitação
<a name="metrics-perattempt"></a>

Cada chamada de API pode exigir várias tentativas antes de receber uma resposta. Essas métricas são coletadas para cada tentativa.

### Métricas principais
<a name="metrics-perattempt-core"></a>


| Nome da métrica | Description | Tipo | 
| --- | --- | --- | 
|  AwsExtendedRequestId  |  O ID da solicitação estendida da solicitação de serviço.  |  String  | 
|  AwsRequestId  |  O ID da solicitação de serviço.  |  String  | 
|  BackoffDelayDuration  |  O tempo que o SDK esperou antes dessa tentativa de chamada de API. O valor é baseado no conjunto `[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)` do cliente. Veja mais informações na seção [Estratégias de novas tentativas](retry-strategy.md#retry-strategies) a seguir deste guia.  |  Duração\$1  | 
| ErrorType |  O tipo de erro que ocorreu em uma tentativa de chamada. Os valores possíveis são: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/metrics-list.html)  | String | 
| ReadThroughput |  O throughput de leitura do cliente, definido como `NumberOfResponseBytesRead / (TTLB - TTFB)`. Esse valor está em bytes por segundo. Observe que essa métrica mede apenas os bytes lidos de dentro do `ResponseTransformer` ou `AsyncResponseTransformer`. Os dados lidos fora do transformador, por exemplo, quando o fluxo de resposta é retornado como resultado do transformador, não são incluídos no cálculo.  | Duplo | 
| WriteThroughput |  A taxa de transferência de gravação do cliente, definida como`RequestBytesWritten / (LastByteWrittenTime - FirstByteWrittenTime)`. Esse valor está em bytes por segundo. Essa métrica mede a taxa na qual o SDK fornece o corpo da solicitação ao cliente HTTP. Isso exclui a configuração da conexão, o tempo de handshake TLS e o tempo de processamento do servidor. Essa métrica só é relatada para solicitações que têm um corpo de streaming, como o S3 PutObject. Observe que essa métrica não leva em conta o buffer na camada do cliente HTTP. A taxa real de transmissão da rede pode ser menor se o cliente HTTP armazenar dados em buffer antes do envio. Essa métrica representa um limite superior da taxa de transferência da rede.  | Duplo | 
|  ServiceCallDuration  |  O tempo necessário para se conectar ao serviço (ou adquirir uma conexão do pool de conexões), enviar a solicitação serializada e receber a resposta inicial (por exemplo, código de status e cabeçalhos HTTP). Isso NÃO inclui o tempo para ler toda a resposta do serviço.  |  Duração\$1  | 
|  SigningDuration  |  O tempo necessário para assinar a solicitação HTTP.  |  Duração\$1  | 
| TimeToFirstByte | O tempo necessário do envio da solicitação HTTP (incluindo a aquisição de uma conexão) até o serviço e o recebimento do primeiro byte dos cabeçalhos na resposta. | Duração\$1 | 
| TimeToLastByte |  O tempo necessário do envio da solicitação HTTP (incluindo a aquisição de uma conexão) até o serviço e o recebimento do último byte da resposta. Observe que, para APIs essas respostas de streaming de retorno, essa métrica abrange o tempo até a `AsyncResponseTransformer` conclusão do `ResponseTransformer` ou.  | Duração\$1 | 
|  UnmarshallingDuration  |  O tempo necessário para desvincular uma resposta HTTP de uma resposta do SDK. Observação: para operações de streaming, isso não inclui o tempo de leitura da carga útil da resposta.  |  Duração\$1  | 

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

### Métricas HTTP
<a name="metrics-perattempt-http"></a>


| Nome da métrica | Description | Tipo | Um cliente HTTP é necessário\$1 | 
| --- | --- | --- | --- | 
|  AvailableConcurrency  |  O número de solicitações simultâneas adicionais que o cliente HTTP suporta sem estabelecer novas conexões com o servidor de destino. Para operações HTTP/1, isso é igual ao número de conexões TCP ociosas estabelecidas com o serviço. Para operações HTTP/2, isso é igual ao número de fluxos ociosos. Observação: esse valor varia de acordo com a implementação do cliente HTTP: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/metrics-list.html) O valor tem como escopo uma instância individual do cliente HTTP e exclui a simultaneidade de outros clientes HTTP na mesma JVM.  |  Inteiro  | Apache, Netty, CRT | 
|  ConcurrencyAcquireDuration  |  O tempo necessário para adquirir um canal do grupo de conexões. Para operações HTTP/1, um canal é igual a uma conexão TCP. Para operações HTTP/2, um canal é igual a um canal de fluxo HTTP/2. A aquisição de um novo canal pode incluir tempo para: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/metrics-list.html)  |  Duração\$1  |  Apache, Netty, CRT  | 
|  HttpClientName  |  O nome do HTTP usado para a solicitação.  |  String  |  Apache, Netty, CRT  | 
|  HttpStatusCode  |  O código de status da resposta HTTP.  |  Inteiro  |  Any  | 
|  LeasedConcurrency  |  O número de solicitações que estão sendo executadas atualmente pelo cliente HTTP.  Para operações HTTP/1, isso é igual ao número de conexões TCP ativas estabelecidas com o serviço (excluindo conexões ociosas). Para operações HTTP/2, isso é igual ao número de fluxos HTTP ativos com o serviço (excluindo a capacidade de fluxo ocioso).  Observação: esse valor varia de acordo com a implementação do cliente HTTP: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/metrics-list.html) O valor tem como escopo uma instância individual do cliente HTTP e exclui a simultaneidade de outros clientes HTTP na mesma JVM.  |  Inteiro  |  Apache, Netty, CRT  | 
|  LocalStreamWindowSize  |  O tamanho da janela HTTP/2 local em bytes para o fluxo que executa essa solicitação.  |  Inteiro  |  Netty  | 
|  MaxConcurrency  |  O número máximo de solicitações simultâneas que o cliente HTTP suporta. Para operações HTTP/1, isso é igual ao número máximo de conexões TCP que o cliente HTTP pode agrupar. Para operações HTTP/2, isso é igual ao número máximo de fluxos que o cliente HTTP pode agrupar. Observação: esse valor varia de acordo com a implementação do cliente HTTP: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/metrics-list.html) O valor tem como escopo uma instância individual do cliente HTTP e exclui a simultaneidade de outros clientes HTTP na mesma JVM.  |  Inteiro  |  Apache, Netty, CRT  | 
|  PendingConcurrencyAcquires  |  O número de solicitações que aguardam a simultaneidade do cliente HTTP. Para operações HTTP/1, isso é igual ao número de solicitações que aguardam o estabelecimento ou o retorno de uma conexão TCP do pool de conexões. Para operações HTTP/2, isso é igual ao número de solicitações que aguardam um novo fluxo (e, possivelmente, uma nova conexão HTTP/2) do grupo de conexões. Observação: esse valor varia de acordo com a implementação do cliente HTTP: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sdk-for-java/latest/developer-guide/metrics-list.html) O valor tem como escopo uma instância individual do cliente HTTP e exclui a simultaneidade de outros clientes HTTP na mesma JVM.  |  Inteiro  |  Apache, Netty, CRT  | 
|  RemoteStreamWindowSize  |  O tamanho da janela HTTP/2 remota em bytes para o fluxo que executa essa solicitação.  |  Inteiro  |  Netty  | 

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

Os termos usados na coluna significam:
+ Apache: o cliente HTTP baseado no Apache (`[ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)`)
+ Netty: o cliente HTTP baseado em Netty (`[NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)`)
+ CRT: o cliente HTTP AWS baseado em CRT () `[AwsCrtAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/crt/AwsCrtAsyncHttpClient.html)`
+ Qualquer: a coleta de dados métricos não depende do cliente HTTP; isso inclui o cliente HTTP URLConnection baseado (`[UrlConnectionHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/urlconnection/UrlConnectionHttpClient.html)`)

# Monitorar aplicações AWS SDK for Java 2.x
<a name="monitoring-overview"></a>

O monitoramento é uma parte importante para manter a confiabilidade, a disponibilidade e o desempenho de aplicações usando o AWS SDK for Java 2.x. A AWS fornece as ferramentas de monitoramento para observar o SDK para Java 2.x, informar quando algo está errado e realizar ações automaticamente quando apropriado:
+ O *Amazon CloudWatch* monitora os recursos da AWS e as aplicações que você executa na AWS em tempo real. Você pode coletar e rastrear métricas, criar painéis personalizados e definir alarmes que o notificam ou que realizam ações quando uma métrica especificada atinge um limite definido. Por exemplo, você pode fazer o CloudWatch acompanhar o uso da CPU ou outras métricas das instâncias do Amazon EC2 e iniciar automaticamente novas instâncias quando necessário. Para obter mais informações, consulte o [Guia do usuário do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
+ O *Amazon CloudWatch Logs* permite monitorar, armazenar e acessar seus arquivos de log das instâncias do Amazon EC2, do CloudTrail e de outras fontes. O CloudWatch Logs pode monitorar informações nos arquivos de log e notificar você quando certos limites forem atingidos. É possível também arquivar seus dados de log em armazenamento resiliente. Para obter mais informações, consulte o [Guia do usuário do Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).
+ O *AWS CloudTrail* captura chamadas de API e eventos relacionados feitos por sua conta da AWS ou em nome dela e entrega os arquivos de log a um bucket do Amazon S3 especificado por você. Você pode identificar quais usuários e contas chamaram a AWS, o endereço IP de origem no qual as chamadas foram feitas e quando elas ocorreram. Para obter mais informações, consulte o [Guia do usuário do AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

# Registro em log com o SDK para Java 2.x
<a name="logging-slf4j"></a>

O AWS SDK for Java 2.x usa [SLF4J](https://www.slf4j.org/manual.html), que é uma camada de abstração que permite o uso de qualquer um dos vários sistemas de registro em tempo de execução.

Entre os sistemas de registro em log compatíveis estão o Java Logging Framework e o Apache [ Log4j 2](https://logging.apache.org/log4j/2.x/), entre outros. Este tópico mostra como usar o Log4j 2 como sistema de registro para trabalhar com o SDK.

## Arquivo de configuração do Log4j 2
<a name="log4j-configuration-file"></a>

Normalmente, você usa um arquivo de configuração, chamado `log4j2.xml` com Log4j 2. Os arquivos de configuração de exemplo são mostrados abaixo. Para saber mais sobre os valores usados no arquivo de configuração, consulte o [manual de configuração do Log4j](https://logging.apache.org/log4j/2.x/manual/configuration.html).

O arquivo `log4j2.xml` precisa estar no caminho de classe quando seu aplicativo é inicializado. Para um projeto do Maven, coloque o arquivo no diretório `<project-dir>/src/main/resources`.

O arquivo de configuração `log4j2.xml` especifica propriedades como [nível de registro em log](https://logging.apache.org/log4j/2.x/manual/configuration.html#Loggers), em que a saída do registro em log é enviada (por exemplo, [para um arquivo ou para o console](https://logging.apache.org/log4j/2.x/manual/appenders.html)) e o [formato da saída](https://logging.apache.org/log4j/2.x/manual/layouts.html). O nível de registro especifica o nível de detalhe que o Log4j 2 gera. O Log4j 2 dá suporte ao conceito de múltiplas [https://logging.apache.org/log4j/2.x/manual/architecture.html#](https://logging.apache.org/log4j/2.x/manual/architecture.html#) de registro em log. O nível de registro em log é definido de maneira independente para cada hierarquia. A hierarquia de registro principal que você usa com o AWS SDK for Java 2.x é`software.amazon.awssdk`.

## Adicionar dependência de registro
<a name="sdk-java-logging-classpath"></a>

Para configurar a associação Log4j 2 para SLF4 J em seu arquivo de compilação, use o seguinte.

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

Adicione os elementos a seguir ao arquivo `pom.xml`:

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

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

Adicione o seguinte ao arquivo `build.gradle.kts`:

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

------

A versão mínima do artefato `log4j-slf4j2-impl` a ser usada é a `2.20.0`. Para a versão mais recente, use a versão publicada no [Maven central](https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-slf4j2-impl). *VERSION*Substitua pela versão que você usará.

## Erros e avisos específicos do SDK
<a name="sdk-java-logging-service"></a>

Recomendamos sempre deixar a hierarquia do registrador em log "software.amazon.awssdk" definida como "WARN" para interceptar todas as mensagens importantes das bibliotecas de cliente do SDK. Por exemplo, se o cliente do Amazon S3 detectar que o aplicativo não fechou corretamente um `InputStream` e possa estar vazando recursos, o cliente do S3 informará isso por meio de uma mensagem de aviso para os logs. Isso também garante que as mensagens serão registradas em log se o cliente enfrentar algum problema ao processar requisições ou respostas.

O arquivo `log4j2.xml` a seguir define o `rootLogger` como “AVISO”, o que faz com que mensagens de aviso e nível de erro de todos os registradores do aplicativo sejam enviadas, *incluindo* aqueles na hierarquia “software.amazon.awssdk”. Você também pode definir explicitamente a hierarquia do registrador em log “software.amazon.awssdk” como “AVISO” se `<Root level="ERROR">` for usado.

**Exemplo de arquivo de configuração Log4j2.xml**

Essa configuração registrará mensagens nos níveis “ERRO” e “AVISO” no console para todas as hierarquias de registradores.

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

## Registro em log do resumo de requisição/resposta
<a name="sdk-java-logging-request-response"></a>

Cada solicitação para um AWS service (Serviço da AWS) gera um ID de AWS solicitação exclusivo que é útil se você tiver problemas com a forma como um AWS service (Serviço da AWS) está lidando com uma solicitação. AWS IDs as solicitações podem ser acessadas programaticamente por meio de [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())objetos no SDK para qualquer chamada de serviço com falha e também podem ser relatadas por meio do nível de registro “DEBUG” do registrador “software.amazon.awssdk.request”.

O arquivo `log4j2.xml` a seguir permite um resumo de solicitações e respostas.

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

Aqui está um exemplo da saída do log:

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

Se você estiver interessado apenas no ID de solicitação, use`<Logger name="software.amazon.awssdk.requestId" level="DEBUG" />`.

## Registro em log do SDK no nível de depuração
<a name="sdk-debug-level-logging"></a>

Se precisar de mais detalhes sobre o que o SDK está fazendo, você pode definir o nível de registro em log do logger `software.amazon.awssdk` como `DEBUG`. Nesse nível, o SDK gera uma grande quantidade de detalhes, então recomendamos que você defina esse nível para resolver erros usando testes de integração. 

Nesse nível de registro em log, o SDK registra informações sobre configuração, resolução de credenciais, interceptores de execução, atividade de TLS de alto nível, assinatura de solicitações e muito mais.

Veja a seguir uma amostra das declarações que são geradas pelo SDK no nível `DEBUG` para uma chamada `S3Client#listBuckets()`.

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

O arquivo `log4j2.xml` a seguir configura a saída anterior.

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

## Ativar o registro em log em nível de rede
<a name="sdk-java-logging-verbose"></a>

Em alguns casos, pode ser útil ver as requisições e as respostas exatas enviadas e recebidas pelo SDK para Java 2.x. Se precisar acessar essas informações, você pode ativá-las temporariamente adicionando a configuração necessária, dependendo do cliente HTTP usado pelo cliente de serviço.

Por padrão, clientes de serviços síncronos, como o [S3Client](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html), usam um Apache subjacente, e clientes de serviços assíncronos HttpClient, como o [S3 AsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html), usam um cliente HTTP Netty sem bloqueio.

Aqui está um detalhamento dos clientes HTTP que podem ser usados para as duas categorias de clientes de serviço:


| Clientes síncronos | Clientes de HTTP assíncronos | 
| --- | --- | 
| [ApacheHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html) (padrão) | [NettyNioAsyncHttpClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html) (padrão) | 
| [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)  | 

Consulte a guia apropriada abaixo para ver as configurações que você precisa adicionar conforme o cliente HTTP subjacente.

**Atenção**  
Recomendamos que você use o arquivo de log somente para fins de depuração. Desative-o em seus ambientes de produção, pois ele pode registrar dados confidenciais. Ele registra a solicitação ou resposta completa sem criptografia, até mesmo para uma chamada HTTPS. Para solicitações ou respostas grandes (por exemplo, para fazer upload de um arquivo Amazon S3), o registro detalhado de conexões também pode afetar significativamente o desempenho do seu aplicativo.

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

Adicione o registrador “org.apache.http.wire” ao arquivo de configuração `log4j2.xml` e defina o nível como “DEBUG”.

O `log4j2.xml` arquivo a seguir ativa o registro completo de conexões para o 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>
```

É necessária uma dependência adicional do Maven no artefato `log4j-1.2-api` para o registro de transmissão de dados com o Apache, pois ele usa 1.2 internamente. 

O conjunto completo de dependências do Maven para o log4j 2, incluindo o registro de transmissão de dados para o cliente Apache HTTP, é mostrado nos trechos do arquivo de compilação a seguir.

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

**DSL Gradle—Kotlin**

```
...
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")
}
...
```

A versão mínima do artefato `log4j-bom` a ser usada é a `2.20.0`. Para a versão mais recente, use a versão publicada no [Maven central](https://central.sonatype.com/artifact/org.apache.logging.log4j/log4j-bom). *VERSION*Substitua pela versão que você usará.

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

Adicione o registrador “org.apache.hc.client5.http.wire” ao arquivo de configuração e defina o nível como “DEBUG”. `log4j2.xml`

O `log4j2.xml` arquivo a seguir ativa o registro completo de conexões para o Apache5 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 ]

Para registrar detalhes de clientes de serviço que usam `UrlConnectionHttpClient`, primeiro crie um arquivo `logging.properties` com o seguinte conteúdo:

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

Defina a seguinte propriedade do sistema JVM com o caminho completo de `logging.properties`:

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

Essa configuração registrará somente os cabeçalhos de solicitação e de resposta, por exemplo:

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

Para ver os request/response corpos, adicione `-Djavax.net.debug=all` às propriedades da JVM. Essa propriedade adicional registra uma grande quantidade de informações, incluindo todas as informações de SSL. 

No console de log ou no arquivo de log, pesquise `"GET"` ou `"POST"` para acessar rapidamente a seção de log que contém solicitações e respostas reais. Pesquise `"Plaintext before ENCRYPTION"` para solicitações e `"Plaintext after DECRYPTION"` para respostas para ver o texto completo dos cabeçalhos e corpos.

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

Se seu cliente de serviço assíncrono usa o `NettyNioAsyncHttpClient` padrão, adicione dois registradores adicionais ao seu arquivo `log4j2.xml` para registrar cabeçalhos HTTP e corpos de solicitação e resposta.

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

Veja aqui um exemplo de `log4j2.xml` completo:

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

Essas configurações registram todos os detalhes e request/response corpos do cabeçalho.

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

Se você configurou o cliente de serviço para usar uma instância de um cliente HTTP baseado no AWS CRT, é possível registrar detalhes definindo as propriedades do sistema de JVM ou de forma programática.


|  | 
| --- |
|  Log to a file at "Debug" level  | 
|  Como usar as propriedades do sistema: <pre>-Daws.crt.log.level=Trace <br />-Daws.crt.log.destination=File <br />-Daws.crt.log.filename=<path to file></pre>  |  Programaticamente: <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  | 
|  Como usar as propriedades do sistema: <pre>-Daws.crt.log.level=Trace <br />-Daws.crt.log.destination=Stdout</pre>  |  Programaticamente: <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>  | 

Por motivos de segurança, no nível “Trace”, os clientes HTTP AWS baseados em CRT registram somente cabeçalhos de resposta. Cabeçalhos de solicitação, corpos de solicitação e corpos de resposta não são registrados.

------