Criar uma função que retorna logs Usar controles avançados de registro em log do Lambda com Java Registro em log avançado com Log4j2 e SLF4J Ferramentas e bibliotecas Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado Usar o console do Lambda Usando o console do CloudWatch Usar a AWS Command Line Interface (AWS CLI)Excluir logs Código de exemplo de registro em log

Registro em log da função do AWS Lambda em Java

O AWS Lambda monitora automaticamente as funções do Lambda e envia entradas de logs para o Amazon CloudWatch. Sua função do Lambda vem com um grupo de logs do CloudWatch Logs e uma transmissão de logs para cada instância de sua função. O ambiente de runtime do Lambda envia detalhes sobre cada invocação e outras saídas do código da função para o fluxo de logs. Para obter mais informações sobre o CloudWatch Logs, consulte Usar logs do Amazon CloudWatch com o AWS Lambda.

Para gerar os logs do código da sua função, use métodos no java.lang.System ou qualquer módulo de registro em log que grave em stdout ou stderr.

Seções

Criar uma função que retorna logs
Usar controles avançados de registro em log do Lambda com Java
Registro em log avançado com Log4j2 e SLF4J
Outras ferramentas e bibliotecas
Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado
Usar o console do Lambda
Usando o console do CloudWatch
Usar a AWS Command Line Interface (AWS CLI)
Excluir logs
Código de exemplo de registro em log

Criar uma função que retorna logs

Para gerar os logs do código da função, use métodos no java.lang.System ou qualquer módulo de registro em log que grave no stdout ou no stderr. A biblioteca aws-lambda-java-core fornece uma classe do logger chamada LambdaLogger que você pode acessar a partir do objeto de contexto. A classe do logger oferece suporte a logs de várias linhas.

O exemplo a seguir usa o logger LambdaLogger fornecido pelo objeto de contexto.

exemplo Handler.java


// Handler value: example.Handler
public class Handler implements RequestHandler<Object, String>{
  Gson gson = new GsonBuilder().setPrettyPrinting().create();
  @Override
  public String handleRequest(Object event, Context context)
  {
    LambdaLogger logger = context.getLogger();
    String response = new String("SUCCESS");
    // log execution details
    logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
    logger.log("CONTEXT: " + gson.toJson(context));
    // process event
    logger.log("EVENT: " + gson.toJson(event));
    return response;
  }
}

exemplo formato do log


START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
ENVIRONMENT VARIABLES: 
{
    "_HANDLER": "example.Handler",
    "AWS_EXECUTION_ENV": "AWS_Lambda_java8",
    "AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
    ...
}
CONTEXT: 
{
    "memoryLimit": 512,
    "awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
    "functionName": "java-console",
    ...
}
EVENT:
{
  "records": [
    {
      "messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
      "receiptHandle": "MessageReceiptHandle",
      "body": "Hello from SQS!",
       ...
    }
  ]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0	Duration: 198.50 ms	Billed Duration: 200 ms	Memory Size: 512 MB	Max Memory Used: 90 MB	Init Duration: 524.75 ms

O runtime do Java registra em log as linhas START, END e REPORT para cada invocação. A linha do relatório fornece os seguintes detalhes:

RELATAR campos de dados de linha

RequestId: o ID de solicitação exclusivo para a invocação.
Duração: a quantidade de tempo que o método de manipulador da função gastou processando o evento.
Duração faturada: a quantia de tempo faturada para a invocação.
Tamanho da memória: a quantidade de memória alocada para a função.
Memória máxima utilizada: a quantidade de memória utilizada pela função.
Duração inicial: para a primeira solicitação atendida, a quantidade de tempo que o runtime levou para carregar a função e executar o código fora do método do handler.
XRAY TraceId: para solicitações rastreadas, o ID de rastreamento do AWS X-Ray.
SegmentId: para solicitações rastreadas, o ID do segmento do X-Ray.
Amostragem: para solicitações rastreadas, o resultado da amostragem.

Usar controles avançados de registro em log do Lambda com Java

Para dar mais controle sobre como os logs das funções são capturados, processados e consumidos, você pode configurar as seguintes opções de log para runtimes compatíveis do Java:

Formato do log: selecione entre texto simples e formato JSON estruturado para os logs da sua função.
Nível de log: para logs no formato JSON, escolha o nível de detalhe dos logs enviados pelo Lambda para o CloudWatch, como ERROR, DEBUG ou INFO.
Grupo de logs: escolha o grupo de logs do CloudWatch para o qual sua função envia logs.

Para obter mais informações sobre essas opções de registro em log e instruções sobre como configurar a função para usá-las, consulte Configurar controles avançados de registro em log para a função do Lambda.

Para usar as opções de formato de log e nível de log com as funções do Lambda para Java, consulte as orientações nas seções a seguir.

Usar logs em formato JSON estruturado com Java

Se você selecionar JSON para o formato de log da função, o Lambda enviará a saída de logs usando a classe LambdaLogger como JSON estruturado. Cada objeto de log JSON contém pelo menos quatro pares de valores-chave com as seguintes chaves:

"timestamp": o horário em que a mensagem de log foi gerada.
"level": o nível de log atribuído à mensagem.
"message": o conteúdo da mensagem de log.
"AWSrequestId": o ID de solicitação exclusivo para invocar a função.

Dependendo do método de registro em log usado, as saídas de log da função capturadas no formato JSON também podem conter pares de valores de chave adicionais.

Para atribuir um nível aos logs que você criar usando o logger LambdaLogger, você precisa fornecer um argumento LogLevel no comando de registro em log, conforme mostrado no exemplo a seguir.

exemplo Código de registro em log do Java


LambdaLogger logger = context.getLogger();
logger.log("This is a debug log", LogLevel.DEBUG);

A saída de log desse exemplo de código seria capturada no CloudWatch Logs da seguinte forma:

exemplo Registro em log JSON


{
    "timestamp":"2023-11-01T00:21:51.358Z",
    "level":"DEBUG",
    "message":"This is a debug log",
    "AWSrequestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}

Se você não atribuir um nível à saída de log, o Lambda atribuirá automaticamente o nível INFO a ele.

Se o código já usa outra biblioteca de logs para produzir logs JSON estruturados, você não precisa fazer nenhuma alteração. O Lambda não codifica duas vezes nenhum log que já esteja codificado em JSON. Mesmo que a função seja configurada para usar logs em formato JSON, suas saídas de log serão exibidas no CloudWatch com a estrutura JSON que você definiu.

Usar a filtragem em nível de log com Java

Para o AWS Lambda filtrar os logs de aplicação de acordo com o nível de log, a função precisa usar logs em formato JSON. Isso pode ser feito de duas maneiras:

Crie saídas de log usando o padrão LambdaLogger e configure a função para usar logs em formato JSON. Assim, o Lambda filtrará as saídas de log usando o par de valores-chave “nível” no objeto JSON descrito em Usar logs em formato JSON estruturado com Java. Para saber como configurar o formato de log da função, consulte Configurar controles avançados de registro em log para a função do Lambda.
Use outro método ou biblioteca de logs para criar logs JSON estruturados no código, de modo que incluam um par de valores-chave de “nível” para definir o nível da saída de log. Você também pode usar qualquer biblioteca de logs que permita a gravação em logs JSON em stdout ou stderr. Por exemplo, é possível usar o Powertools para AWS Lambda ou o pacote Log4j2 para gerar saídas de log JSON estruturado do seu código. Consulte Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado e Registro em log avançado com Log4j2 e SLF4J para saber mais.

Ao configurar sua função para usar a filtragem em nível de log, você precisa selecionar entre as seguintes opções para o nível do logs enviados pelo Lambda para o CloudWatch Logs:

Nível de log	Uso padrão
TRACE (mais detalhes)	As informações mais detalhadas usadas para rastrear o caminho da execução do código
DEBUG	Informações detalhadas para depuração do sistema
INFO	Mensagens que registram a operação normal da função
WARN	Mensagens sobre possíveis erros que podem levar a um comportamento inesperado se não forem corrigidos
ERRO	Mensagens sobre problemas que impedem que o código funcione conforme o esperado
FATAL (menos detalhes)	Mensagens sobre erros graves que fazem a aplicação parar de funcionar

Para que o Lambda filtre os logs da função, você também precisa incluir um par de valores-chave "timestamp" na saída do log JSON. A hora deve ser especificada em um formato RFC 3339 válido de carimbo de data/hora. Se você não fornecer um carimbo de data/hora válido, o Lambda atribuirá ao log o nível INFO e adicionará um carimbo de data/hora.

O Lambda envia logs do nível selecionado, e dos níveis inferiores, para o CloudWatch. Por exemplo, se você configurar um nível de log de WARN, o Lambda enviará logs correspondentes aos níveis WARN, ERROR e FATAL.

Registro em log avançado com Log4j2 e SLF4J

nota

O AWS Lambda não inclui o Log4j2 em seus runtimes gerenciados ou imagens de contêiner base. Portanto, estes não são afetados pelos problemas descritos em CVE-2021-44228, CVE-2021-45046 e CVE-2021-45105.

Para casos em que uma função do cliente contém uma versão do Log4j2 impactada, aplicamos uma alteração aos runtimes gerenciados e imagens do contêiner base do Lambda Java que ajuda a mitigar os problemas em CVE-2021-44228, CVE-2021-45046 e CVE-2021-45105. Como resultado dessa alteração, os clientes que usam o Log4J2 podem ver mais uma entrada de log, semelhante a “Transforming org/apache/logging/log4j/core/lookup/JndiLookup (java.net.URLClassLoader@...)”. Todas as strings de log que referenciem o mapeador jndi na saída Log4J2 serão substituídas por “Patched JndiLookup::lookup()”.

Independentemente dessa mudança, é altamente recomendável que todos os clientes cujas funções incluam o Log4j2 atualizem para a versão mais recente. Especificamente, os clientes que usam a biblioteca aws-lambda-java-log4j2 em suas funções devem atualizar para a versão 1.5.0 (ou posterior) e reimplantar suas funções. Essa versão atualiza as dependências do utilitário Log4j2 subjacentes para a versão 2.17.0 (ou posterior). O binário aws-lambda-java-log4j2 atualizado está disponível no repositório do Maven, e seu código-fonte está disponível no Github.

Por fim, observe que qualquer biblioteca relacionada ao aws-lambda-java-log4j (v1.0.0 or 1.0.1) não deve ser usada em nenhuma circunstância. Essas bibliotecas estão relacionadas à versão 1.x do log4j, que foi encerrada em 2015. Não há suporte, manutenção nem patches para essas bibliotecas, e elas apresentam vulnerabilidades de segurança conhecidas.

Para personalizar a saída de log, oferecer suporte ao registro em log durante testes de unidade e registrar chamadas do AWS SDK em log, use o Apache Log4j2 com o SLF4J. O Log4j é uma biblioteca de registro em log para programas Java que permite configurar níveis de log e usar bibliotecas de appender. O SLF4J é uma biblioteca de fachada que permite alterar qual biblioteca você usa sem alterar o código da função.

Para adicionar o ID de solicitação aos logs da sua função, use o appender na biblioteca aws-lambda-java-log4j2.

exemplo src/main/resources/log4j2.xml: configuração do appender


<Configuration>
  <Appenders>
    <Lambda name="Lambda" format="${env:AWS_LAMBDA_LOG_FORMAT:-TEXT}">
       <LambdaTextFormat>
         <PatternLayout>
             <pattern>%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n </pattern>
         </PatternLayout>
       </LambdaTextFormat>
       <LambdaJSONFormat>
         <JsonTemplateLayout eventTemplateUri="classpath:LambdaLayout.json" />
       </LambdaJSONFormat>
     </Lambda>
   </Appenders>
   <Loggers>
     <Root level="${env:AWS_LAMBDA_LOG_LEVEL:-INFO}">
       <AppenderRef ref="Lambda"/>
     </Root>
     <Logger name="software.amazon.awssdk" level="WARN" />
     <Logger name="software.amazon.awssdk.request" level="DEBUG" />
   </Loggers>
 </Configuration>

Você pode decidir como os logs do Log4j2 são configurados para saídas em texto simples ou JSON especificando um layout nas tags <LambdaTextFormat> e <LambdaJSONFormat>.

Neste exemplo, no modo de texto, cada linha é precedida com a data, a hora, o ID da solicitação, o nível do log e o nome da classe. No modo JSON, <JsonTemplateLayout> é usado com uma configuração que está incluída na biblioteca aws-lambda-java-log4j2.

O SLF4J é uma biblioteca de fachada para registro em log em código Java. No código da função, use o logger factory SLF4J para recuperar um logger com métodos para níveis de log como info() e warn(). Na configuração da compilação, inclua a biblioteca de registro em log e o adaptador SLF4J no classpath. Alterando as bibliotecas na configuração de compilação, é possível alterar o tipo de logger sem alterar o código da função. O SLF4J é necessário para capturar logs do SDK for Java.

No exemplo de código a seguir, a classe de manipulador usa SLF4J para recuperar um logger.

exemplo src/main/java/example/HandlerS3.java: registro em log com o SLF4J


package example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;

import static org.apache.logging.log4j.CloseableThreadContext.put;


public class HandlerS3 implements RequestHandler<S3Event, String>{
    private static final Logger logger = LoggerFactory.getLogger(HandlerS3.class);

    @Override
    public String handleRequest(S3Event event, Context context) {
        for(var record : event.getRecords()) {
            try (var loggingCtx = put("awsRegion", record.getAwsRegion())) {
                loggingCtx.put("eventName", record.getEventName());
                loggingCtx.put("bucket", record.getS3().getBucket().getName());
                loggingCtx.put("key", record.getS3().getObject().getKey());

                logger.info("Handling s3 event");
            }
        }

        return "Ok";
    }
}

Esse código gera uma saída de log semelhante à seguinte:

exemplo formato do log


{
    "timestamp": "2023-11-15T16:56:00.815Z",
    "level": "INFO",
    "message": "Handling s3 event",
    "logger": "example.HandlerS3",
    "AWSRequestId": "0bced576-3936-4e5a-9dcd-db9477b77f97",
    "awsRegion": "eu-south-1",
    "bucket": "java-logging-test-input-bucket",
    "eventName": "ObjectCreated:Put",
    "key": "test-folder/"
}

A configuração de compilação usa dependências de runtime no appender e no adaptador SLF4J do Lambda, além de dependências de implementação no Log4J2.

exemplo build.gradle: dependências de registro em log


dependencies {
    ...
    'com.amazonaws:aws-lambda-java-log4j2:[1.6.0,)',
    'com.amazonaws:aws-lambda-java-events:[3.11.3,)',
    'org.apache.logging.log4j:log4j-layout-template-json:[2.17.1,)',
    'org.apache.logging.log4j:log4j-slf4j2-impl:[2.19.0,)',
    ...
}

Quando você executa seu código localmente para testes, o objeto de contexto com o logger do Lambda não está disponível e não há nenhum ID de solicitação para o appender do Lambda usar. Para obter exemplos de configurações de teste, consulte as aplicações de exemplo na próxima seção.

Outras ferramentas e bibliotecas

O Powertools para AWS Lambda (Java) é um kit de ferramentas para desenvolvedores para implementar as práticas recomendadas da tecnologia sem servidor e aumentar a velocidade do desenvolvedor. O utilitário de logs fornece um registrador de logs otimizado para Lambda que inclui informações adicionais sobre o contexto da função em todas as suas funções, com saída estruturada como JSON. Use esse utilitário para fazer o seguinte:

Capturar campos-chave do contexto do Lambda, inicialização a frio e estruturas registrando em log a saída como JSON
Registrar em log eventos de invocação do Lambda quando instruído (desativado por padrão)
Imprimir todos os logs somente para uma porcentagem das invocações por meio da amostragem de logs (desativado por padrão)
Anexar chaves adicionais ao log estruturado a qualquer momento
Use um formatador de log personalizado (Bring Your Own Formatter) para gerar logs em uma estrutura compatível com o RFC de logs da sua organização

Uso do Powertools para AWS Lambda (Java) e do AWS SAM para registro em log estruturado

Siga as etapas abaixo para baixar, criar e implantar um exemplo da aplicação Hello World em Java com os módulos integrados do Powertools para AWS Lambda (Java)~ usando o AWS SAM. Esta aplicação implementa um back-end de API básico e usa o Powertools para emitir logs, métricas e rastreamentos. Consiste em um endpoint do Amazon API Gateway e uma função do Lambda. Quando você envia uma solicitação GET ao endpoint do API Gateway, a função do Lambda invoca, envia logs e métricas usando o formato de métricas incorporadas ao CloudWatch e envia rastreamentos ao AWS X-Ray. A função retorna uma mensagem hello world.

Pré-requisitos

Para executar as etapas desta seção, você deve ter o seguinte:

Java 11
AWS CLI versão 2
AWS SAM CLI versão 1.75 ou posterior. Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte Atualizando a CLI do AWS SAM.

Implantar uma aplicação de exemplo do AWS SAM

Inicialize a aplicação usando o modelo Java do Hello World.


sam init --app-template hello-world-powertools-java --name sam-app --package-type Zip --runtime java11 --no-tracing

Crie a aplicação.
```
cd sam-app && sam build
```
Implante o aplicativo.
```
sam deploy --guided
```
Siga as instruções na tela. Para aceitar as opções padrão fornecidas na experiência interativa, pressione Enter.

nota
Em HelloWorldFunction pode não ter autorização definida, tudo bem?, certifique-se de inserir y.

Obtenha o URL da aplicação implantada:


aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text

Invoque o endpoint da API:
```
curl -X GET <URL_FROM_PREVIOUS_STEP>
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```

Para obter os logs da função, execute sam logs. Para obter mais informações, consulte Trabalhar com logs no Guia do desenvolvedor do AWS Serverless Application Model.


sam logs --stack-name sam-app

O resultado de saída do log se parece com:


2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.095000 INIT_START Runtime Version: java:11.v15    Runtime Version ARN: arn:aws:lambda:eu-central-1::runtime:0a25e3e7a1cc9ce404bc435eeb2ad358d8fa64338e618d0c224fe509403583ca
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.114000 Picked up JAVA_TOOL_OPTIONS: -XX:+TieredCompilation -XX:TieredStopAtLevel=1
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:34.793000 Transforming org/apache/logging/log4j/core/lookup/JndiLookup (lambdainternal.CustomerClassLoader@1a6c5a9e)
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:35.252000 START RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765 Version: $LATEST
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.531000 {
  "_aws": {
    "Timestamp": 1675416276051,
    "CloudWatchMetrics": [
      {
        "Namespace": "sam-app-powerools-java",
        "Metrics": [
          {
            "Name": "ColdStart",
            "Unit": "Count"
          }
        ],
        "Dimensions": [
          [
            "Service",
            "FunctionName"
          ]
        ]
      }
    ]
  },
  "function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
  "traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
  "FunctionName": "sam-app-HelloWorldFunction-y9Iu1FLJJBGD",
  "functionVersion": "$LATEST",
  "ColdStart": 1.0,
  "Service": "service_undefined",
  "logStreamId": "2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
  "executionEnvironment": "AWS_Lambda_java11"
}
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.974000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.AWSXRayRecorder <init>
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 Feb 03, 2023 9:24:36 AM com.amazonaws.xray.config.DaemonConfiguration <init>
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:36.993000 INFO: Environment variable AWS_XRAY_DAEMON_ADDRESS is set. Emitting to daemon on address XXXX.XXXX.XXXX.XXXX:2000.
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.331000 09:24:37.294 [main] INFO  helloworld.App - {"version":null,"resource":"/hello","path":"/hello/","httpMethod":"GET","headers":{"Accept":"*/*","CloudFront-Forwarded-Proto":"https","CloudFront-Is-Desktop-Viewer":"true","CloudFront-Is-Mobile-Viewer":"false","CloudFront-Is-SmartTV-Viewer":"false","CloudFront-Is-Tablet-Viewer":"false","CloudFront-Viewer-ASN":"16509","CloudFront-Viewer-Country":"IE","Host":"XXXX.execute-api.eu-central-1.amazonaws.com","User-Agent":"curl/7.86.0","Via":"2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)","X-Amz-Cf-Id":"t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q==","X-Amzn-Trace-Id":"Root=1-63dcd2d1-25f90b9d1c753a783547f4dd","X-Forwarded-For":"XX.XXX.XXX.XX, XX.XXX.XXX.XX","X-Forwarded-Port":"443","X-Forwarded-Proto":"https"},"multiValueHeaders":{"Accept":["*/*"],"CloudFront-Forwarded-Proto":["https"],"CloudFront-Is-Desktop-Viewer":["true"],"CloudFront-Is-Mobile-Viewer":["false"],"CloudFront-Is-SmartTV-Viewer":["false"],"CloudFront-Is-Tablet-Viewer":["false"],"CloudFront-Viewer-ASN":["16509"],"CloudFront-Viewer-Country":["IE"],"Host":["XXXX.execute-api.eu-central-1.amazonaws.com"],"User-Agent":["curl/7.86.0"],"Via":["2.0 f0300a9921a99446a44423d996042050.cloudfront.net (CloudFront)"],"X-Amz-Cf-Id":["t9W5ByT11HaY33NM8YioKECn_4eMpNsOMPfEVRczD7T1RdhbtiwV1Q=="],"X-Amzn-Trace-Id":["Root=1-63dcd2d1-25f90b9d1c753a783547f4dd"],"X-Forwarded-For":["XXX, XXX"],"X-Forwarded-Port":["443"],"X-Forwarded-Proto":["https"]},"queryStringParameters":null,"multiValueQueryStringParameters":null,"pathParameters":null,"stageVariables":null,"requestContext":{"accountId":"XXX","stage":"Prod","resourceId":"at73a1","requestId":"ba09ecd2-acf3-40f6-89af-fad32df67597","operationName":null,"identity":{"cognitoIdentityPoolId":null,"accountId":null,"cognitoIdentityId":null,"caller":null,"apiKey":null,"principalOrgId":null,"sourceIp":"54.240.197.236","cognitoAuthenticationType":null,"cognitoAuthenticationProvider":null,"userArn":null,"userAgent":"curl/7.86.0","user":null,"accessKey":null},"resourcePath":"/hello","httpMethod":"GET","apiId":"XXX","path":"/Prod/hello/","authorizer":null},"body":null,"isBase64Encoded":false}
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:37.351000 09:24:37.351 [main] INFO  helloworld.App - Retrieving https://checkip.amazonaws.com
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.313000 {
  "function_request_id": "7fcf1548-d2d4-41cd-a9a8-6ae47c51f765",
  "traceId": "Root=1-63dcd2d1-25f90b9d1c753a783547f4dd;Parent=e29684c1be352ce4;Sampled=1",
  "xray_trace_id": "1-63dcd2d1-25f90b9d1c753a783547f4dd",
  "functionVersion": "$LATEST",
  "Service": "service_undefined",
  "logStreamId": "2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81",
  "executionEnvironment": "AWS_Lambda_java11"
}
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 END RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765
2023/02/03/[$LATEST]851411a899b545eea2cffeba4cfbec81 2023-02-03T09:24:39.371000 REPORT RequestId: 7fcf1548-d2d4-41cd-a9a8-6ae47c51f765    Duration: 4118.98 ms    Billed Duration: 4119 ms    Memory Size: 512 MB    Max Memory Used: 152 MB    Init Duration: 1155.47 ms    
XRAY TraceId: 1-63dcd2d1-25f90b9d1c753a783547f4dd    SegmentId: 3a028fee19b895cb    Sampled: true

Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste.
```
sam delete
```

Gerenciar a retenção de logs

Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs por tempo indeterminado, exclua o grupo de logs ou configure um período de retenção após o qual o CloudWatch excluirá os logs automaticamente. Para configurar a retenção de logs, adicione o seguinte ao seu modelo do AWS SAM:


Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      # Omitting other properties

  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
      RetentionInDays: 7

Usar o console do Lambda

Você pode usar o console do Lambda para exibir a saída do log depois de invocar uma função do Lambda.

Se seu código puder ser testado no editor de Código incorporado, você encontrará logs nos resultados de execução. Ao usar o recurso de teste do console para invocar uma função, você encontrará Saída de log na seção Detalhes.

Usando o console do CloudWatch

Você pode usar o console do Amazon CloudWatch para exibir registros de todas as invocações da função do Lambda.

Para visualizar logs no console do CloudWatch

No console do Amazon CloudWatch, abra a página Log groups (Grupos de log).
Escolha o grupo de logs de sua função (/aws/lambda/nome-de-sua-função).
Escolha um stream de logs.

Cada fluxo de log corresponde a uma instância da sua função. Uma transmissão de logs é exibida quando você atualiza sua função do Lambda e quando mais instâncias são criadas para lidar com várias invocações simultâneas. Para localizar logs de uma invocação específica, recomendamos intrumentar sua função com AWS X-Ray. O X-Ray registra detalhes sobre a solicitação e o stream de logs no rastreamento.

Usar a AWS Command Line Interface (AWS CLI)

O AWS CLI é uma ferramenta de código aberto que permite interagir com os serviços do AWS usando comandos no shell da linha de comando. Para executar as etapas desta seção, você deve ter o seguinte:

Você pode usar a AWS CLI para recuperar logs de uma invocação usando a opção de comando --log-type. A resposta contém um campo LogResult com até 4 KB de logs codificados em base64 obtidos da invocação.

exemplo recuperar um ID de log

O exemplo a seguir mostra como recuperar um ID de log do campo LogResult para uma função chamada my-function.


aws lambda invoke --function-name my-function out --log-type Tail

A seguinte saída deverá ser mostrada:


{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}

exemplo decodificar os logs

No mesmo prompt de comando, use o utilitário base64 para decodificar os logs. O exemplo a seguir mostra como recuperar logs codificados em base64 de my-function.


aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode

A opção cli-binary-format será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute aws configure set cli-binary-format raw-in-base64-out. Para obter mais informações, consulte A AWS CLI comporta opções de linha de comando globais no Guia do usuário da AWS Command Line Interface versão 2.

A seguinte saída deverá ser mostrada:


START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB

O utilitário base64 está disponível no Linux, macOS e Ubuntu no Windows. Os usuários do macOS precisam usar base64 -D.

exemplo get-logs.sh script

No mesmo prompt de comando, use o script a seguir para fazer download dos últimos cinco eventos de log. O script usa sed para remover as aspas do arquivo de saída e fica inativo por 15 segundos para que os logs tenham tempo de ficar disponíveis. A saída inclui a resposta do Lambda, e a saída do comando get-log-events.

Copie o conteúdo do exemplo de código a seguir e salve no diretório de seu projeto do Lambda como get-logs.sh.


#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5

exemplo macOS e Linux (somente)

No mesmo prompt de comando, os usuários do macOS e do Linux podem precisar executar o comando a seguir para garantir que o script seja executável.


chmod -R 755 get-logs.sh

exemplo recuperar os últimos cinco eventos de log

No mesmo prompt de comando, execute o script a seguir para obter os últimos cinco eventos de log.


./get-logs.sh

A seguinte saída deverá ser mostrada:


{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Excluir logs

Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs indefinidamente, exclua o grupo de logs ouconfigurar um período de retençãoapós o qual os logs são excluídos automaticamente.

Código de exemplo de registro em log

O repositório do GitHub para este guia inclui aplicativos de exemplo que demonstram o uso de várias configurações de registro em log. Cada aplicativo de exemplo inclui scripts para fácil implantação e limpeza, um modelo do AWS SAM e recursos de suporte.

Aplicações de exemplo do Lambda em Java

java17-examples: uma função em Java que demonstra como usar um registro Java para representar um objeto de dados de evento de entrada.
java-basic: uma coleção de funções Java mínimas com testes de unidade e configuração de registro em log variável.
java-events: uma coleção de funções do Java contendo código básico sobre como lidar com eventos de vários serviços, como o Amazon API Gateway, o Amazon SQS e o Amazon Kinesis. Essas funções usam a versão mais recente da biblioteca aws-lambda-java-events (3.0.0 e versões mais recentes). Estes exemplos não exigem oAWS SDK como dependência.
s3-java: uma função em Java que processa eventos de notificação do Amazon S3 e usa a Java Class Library (JCL) para criar miniaturas de arquivos de imagem enviados por upload.
Use API Gateway to invoke a Lambda function (Usar o API Gateway para invocar uma função do Lambda): uma função Java que verifica uma tabela do Amazon DynamoDB contendo informações de funcionários. Em seguida, usa o Amazon Simple Notification Service para enviar uma mensagem de texto aos funcionários comemorando seus aniversários de empresa. Este exemplo usa o API Gateway para invocar a função.

O aplicativo de exemplo java-basic mostra uma configuração mínima de registro em log que oferece suporte a testes de registro em log. O código do manipulador usa o logger LambdaLogger fornecido pelo objeto de contexto. Para testes, a aplicação usa uma classe TestLogger personalizada que implementa a interface LambdaLogger com um logger Log4j2. Ele usa o SLF4J como fachada para compatibilidade com o AWS SDK. As bibliotecas de registro em log são excluídas da saída de compilação para manter o pacote de implantação pequeno.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Contexto

Rastreamento