

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

# Pubblica le metriche SDK per le funzioni utilizzando il AWS Lambda AWS SDK for Java 2.x
<a name="metric-pub-impl-emf"></a>

Poiché le funzioni Lambda vengono in genere eseguite da millisecondi a minuti, qualsiasi ritardo nell'invio delle metriche, che si verifica con il, rischia la `CloudWatchMetricPublisher` perdita di dati. 

`[EmfMetricLoggingPublisher](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.html)`fornisce un approccio più adatto scrivendo immediatamente le metriche come voci di registro strutturate in [CloudWatch Embedded](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format.html) Metric Format (EMF). `EmfMetricLoggingPublisher`funziona in ambienti di esecuzione dotati di integrazione integrata con Amazon CloudWatch Logs come AWS Lambda Amazon Elastic Container Service.

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

Prima di poter abilitare e utilizzare le metriche utilizzando`EmfMetricLoggingPublisher`, completa i seguenti passaggi.

### Passaggio 1: aggiungere la dipendenza richiesta
<a name="metric-pub-impl-emf-set-up-deps"></a>

Configura le dipendenze del progetto (ad esempio, nel tuo `build.gradle` file `pom.xml` o) per utilizzare la versione `2.30.3` o successiva di. AWS SDK per Java

Includi l'`emf-metric-logging-publisher`ArtifactID con il `2.30.3` numero di versione o successivo nelle dipendenze del progetto.

Esempio:

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

### Passaggio 2: configura le autorizzazioni richieste
<a name="metric-pub-impl-emf-set-up-perm"></a>

Abilita `logs:PutLogEvents` le autorizzazioni per l'identità IAM utilizzata dall'editore delle metriche per consentire all'SDK for Java di scrivere log in formato EMF.

### Fase 3: Configurazione della registrazione
<a name="metric-pub-impl-emf-set-up-logger"></a>

Per garantire una corretta raccolta delle metriche, configura la registrazione in modo che venga inviata alla console a un `INFO` livello o inferiore (ad esempio). `DEBUG` Nel tuo `log4j2.xml` file:

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

Per ulteriori informazioni su come configurare un `log4j2.xml` file, consulta l'[argomento relativo alla registrazione](logging-slf4j.md) in questa guida. 

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

La seguente classe di funzioni Lambda crea e configura prima un'`EmfMetricLoggingPublisher`istanza e poi la utilizza con un client di servizio 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 il client DynamoDB esegue il metodo, pubblica automaticamente `putItem` le metriche in un flusso di log in formato EMF. CloudWatch 

### Esempio di evento di registro EMF
<a name="emf-logged-output"></a>

Ad esempio, se invii il seguente evento alla funzione GameHandler Lambda con la registrazione configurata come mostrato in precedenza:

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

Dopo che la funzione ha elaborato l'evento, trovate due eventi di registro simili all'esempio seguente. L'oggetto JSON nel secondo evento contiene i dati metrici Java SDK per l'`PutItem`operazione su DynamoDB.

Quando CloudWatch riceve un evento di registro in formato EMF, analizza automaticamente il codice JSON strutturato per estrarre i dati metrici. CloudWatch quindi crea le metriche corrispondenti durante l'archiviazione della voce di registro originale in Logs. CloudWatch 

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

La [documentazione dell'API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/metrics/publishers/emf/EmfMetricLoggingPublisher.Builder.html) `EmfMetricLoggingPublisher.Builder` mostra le opzioni di configurazione che è possibile utilizzare.

È inoltre possibile abilitare la registrazione delle metriche EMF per una singola richiesta, come [mostrato](metric-pub-impl-cwmp.md#enable-metrics-for-a-specific-request) per. CloudWatchMetricPublisher

**Passaggi successivi:** per le applicazioni a esecuzione prolungata, consulta [Pubblicazione delle metriche SDK da applicazioni a esecuzione prolungata per la pubblicazione di metriche](metric-pub-impl-cwmp.md) basate su metriche. CloudWatch