# Enviar logs de função do Lambda para o CloudWatch Logs
Por padrão, o Lambda captura automaticamente os logs de todas as invocações de função e os envia para o CloudWatch Logs, desde que o perfil de execução da função tenha as permissões necessárias. Por padrão, esses logs são armazenados em um grupo de logs denominado /aws/lambda/**. Para aprimorar a depuração, você pode inserir instruções personalizadas de registro em log no código que o Lambda integrará perfeitamente ao CloudWatch Logs. Se necessário, você pode configurar a função para enviar logs para outro grupo usando o console do Lambda, a AWS CLI ou a API do Lambda. Para saber mais, consulte [Configurar grupos de logs do CloudWatch](monitoring-cloudwatchlogs-loggroups.md).
Você pode visualizar os logs de funções do Lambda usando o console do Lambda, o console do CloudWatch, a AWS Command Line Interface (AWS CLI) ou a API do CloudWatch. Para obter mais informações, consulte [Visualização dos logs do CloudWatch para funções do Lambda](monitoring-cloudwatchlogs-view.md).
**nota**
Pode levar de 5 a 10 minutos para que os logs apareçam após uma invocação de função.
## Permissões obrigatórias do IAM
O [perfil de execução](lambda-intro-execution-role.md) precisa de permissão para carregar logs no CloudWatch Logs:
+ `logs:CreateLogGroup`
+ `logs:CreateLogStream`
+ `logs:PutLogEvents`
Para saber mais, consulte [Usar políticas baseadas em identidade (políticas do IAM) para o CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-identity-based-access-control-cwl.html) no *Guia do usuário do Amazon CloudWatch*.
Você pode adicionar essas permissões do CloudWatch Logs usando uma política gerenciada da AWS `AWSLambdaBasicExecutionRole` fornecida pelo Lambda. Para adicionar essa política à sua função, execute o seguinte comando:
```
aws iam attach-role-policy --role-name your-role --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
```
Para obter mais informações, consulte [Trabalhar com políticas gerenciadas pela AWS no perfil de execução](permissions-managed-policies.md).
## Preços
Não há nenhuma cobrança adicional para usar os logs do Lambda, porém, a cobrança padrão do CloudWatch Logs é aplicável. Para obter mais informações, consulte [Preço do CloudWatch.](https://aws.amazon.com/cloudwatch/pricing/)
# Configurar grupos de logs do CloudWatch
Por padrão, o CloudWatch cria automaticamente um grupo de logs denominado `/aws/lambda/` para a função quando ela é invocada pela primeira vez. Para configurar a função para enviar logs a um grupo de logs existente ou para criar um novo grupo de logs para a função, você pode usar a AWS CLI ou o console do Lambda. Também é possível configurar grupos de logs personalizados usando os comandos [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html) e [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) da API do Lambda e o recurso do AWS Serverless Application Model (AWS SAM) [AWS::Serverless::Function]().
É possível configurar várias funções do Lambda para enviar logs ao mesmo grupo de logs do CloudWatch. Por exemplo, é possível usar um único grupo de logs para armazenar os logs de todas as funções do Lambda que fizerem parte de uma aplicação específica. Quando você usa um grupo de logs personalizado para uma função do Lambda, os fluxos de log criados pelo Lambda incluem o nome e a versão da função. Isso garante que o mapeamento entre mensagens de log e funções seja preservado, mesmo se você usar o mesmo grupo de logs para várias funções.
O formato de nomenclatura de fluxos de logs para grupos de logs personalizados segue esta convenção:
```
YYYY/MM/DD/[][]
```
Observe que, ao configurar um grupo de logs personalizado, o nome selecionado para o grupo de logs deve seguir as [regras de nomenclatura do CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html). Além disso, nomes de grupos de logs personalizados não devem começar com a string `aws/`. Se você criar um grupo de logs personalizado começando com `aws/`, o Lambda não conseguirá criar o grupo de logs. Como resultado, os logs da função não serão enviados para o CloudWatch.
**Alterar o grupo de logs de uma função (console)**
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.
1. Escolha uma função.
1. Na página de configuração da função, escolha **Ferramentas de monitoramento e operações**.
1. No painel **Configuração de registro em log**, escolha **Editar**.
1. No painel **Grupo de logs** do **grupo de logs do CloudWatch**, escolha **Personalizado**.
1. Em **Grupo de logs personalizado**, insira o nome do grupo de logs do CloudWatch para o qual você deseja que sua função envie logs. Se você inserir o nome de um grupo de logs existente, sua função usará esse grupo. Se não existir nenhum grupo de logs com o nome inserido, o Lambda criará um novo grupo de logs para a função com esse nome.
**Alterar o grupo de logs de uma função (AWS CLI)**
+ Para alterar o grupo de logs de uma função existente, use o comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html).
```
aws lambda update-function-configuration \
--function-name myFunction \
--logging-config LogGroup=myLogGroup
```
**Especificar um grupo de logs personalizado ao criar uma função (AWS CLI)**
+ Para especificar um grupo de logs personalizado ao criar uma nova função do Lambda usando a AWS CLI, use a opção `--logging-config`. O comando de exemplo a seguir cria uma função do Lambda para Node.js que envia logs para um grupo de logs denominado `myLogGroup`.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x \
--handler index.handler \
--zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/LambdaRole \
--logging-config LogGroup=myLogGroup
```
## Permissões da função de execução
Para que sua função envie logs para o CloudWatch Logs, ela precisa ter a permissão [logs:PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html). Quando você configura o grupo de logs da sua função usando o console do Lambda, o Lambda adiciona essa permissão ao perfil de acordo com as seguintes condições:
+ O destino do serviço está definido como o CloudWatch Logs
+ O perfil de execução da função não tem permissões para carregar logs no CloudWatch Logs (o destino padrão)
**nota**
O Lambda não adiciona nenhuma permissão de Put para destinos de log do Amazon S3 ou Firehose.
Quando o Lambda adiciona essa permissão, ele dá à função permissão para enviar logs para qualquer grupo de logs do CloudWatch Logs.
Para evitar que o Lambda atualize automaticamente o perfil de execução da função e o edite manualmente, expanda **Permissões** e desmarque **Adicionar permissões necessárias**.
Quando você configura o grupo de logs da função usando a AWS CLI, o Lambda não adiciona automaticamente a permissão `logs:PutLogEvents`. Adicione a permissão ao perfil de execução da função, caso isso ainda não tenha sido feito. Essa permissão está incluída na política gerenciada [AWSLambdaBasicExecutionRole](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole$jsonEditor).
## Registro em log do CloudWatch para instâncias gerenciadas do Lambda
Ao usar [instâncias gerenciadas do Lambda](lambda-managed-instances.md), há outras considerações sobre o envio de logs ao CloudWatch Logs:
### Requisitos de rede de VPC
As instâncias gerenciadas do Lambda são executadas em instâncias do EC2 de propriedade do cliente em sua VPC. Para enviar logs para o CloudWatch Logs e rastreamentos para o X-Ray, você deve garantir que essas APIs da AWS sejam roteáveis a partir da sua VPC. Você tem várias opções:
+ **AWS PrivateLink (recomendado)**: use o [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) para criar endpoints da VPC para serviços do CloudWatch e do X-Ray. Isso permite que suas instâncias acessem esses serviços de forma privada, sem a necessidade de um gateway da Internet ou gateway de NAT. Para obter mais informações, consulte [Uso do CloudWatch Logs com endpoints da VPC de interface](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html).
+ **Gateway de NAT**: configure um gateway de NAT para permitir o acesso de saída à Internet a partir de suas sub-redes privadas.
+ **Gateway da Internet**: para sub-redes públicas, certifique-se de que sua VPC tenha um gateway da Internet configurado.
Se as APIs do CloudWatch Logs ou do X-Ray não forem roteáveis a partir da sua VPC, seus logs e rastreamentos de funções não serão entregues.
### Invocações simultâneas e atribuição de logs
Os ambientes de execução das instâncias gerenciadas do Lambda podem processar várias invocações simultaneamente. Quando várias invocações são executadas simultaneamente, suas entradas de log são intercaladas no mesmo fluxo de log. Para filtrar e analisar com eficácia os logs de invocações simultâneas, é necessário garantir que cada entrada de log inclua o ID da solicitação da AWS.
Recomendamos uma das abordagens a seguir:
+ **Use loggers de runtime padrão do Lambda (recomendado)**: as bibliotecas de registro em log padrão fornecidas pelos runtimes gerenciados do Lambda incluem automaticamente o ID da solicitação em cada entrada de log.
+ **Implemente logs JSON estruturados**: se você estiver criando um [runtime personalizado](runtimes-custom.md) ou precisar de um registro em log personalizado, implemente logs em formato JSON que incluam o ID da solicitação em cada entrada. As instâncias gerenciadas do Lambda oferecem suporte somente ao formato de log de JSON. Inclua o campo `requestId` em seus logs de JSON para habilitar a filtragem por invocação:
```
{
"timestamp": "2025-01-15T10:30:00.000Z",
"level": "INFO",
"requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"message": "Processing request"
}
```
Com a atribuição do ID da solicitação, é possível filtrar as entradas de log do CloudWatch Logs para uma invocação específica usando consultas do CloudWatch Logs Insights. Por exemplo:
```
fields @timestamp, @message
| filter requestId = "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
| sort @timestamp asc
```
Para obter mais informações sobre os requisitos de log das instâncias gerenciadas do Lambda, consulte [Noções básicas sobre o ambiente de execução das instâncias gerenciadas do Lambda](lambda-managed-instances-execution-environment.md).
# Visualização dos logs do CloudWatch para funções do Lambda
É possível visualizar os logs do Amazon CloudWatch para sua função do Lambda usando o console do Lambda, o console do CloudWatch ou a AWS Command Line Interface (AWS CLI). Siga as instruções das próximas seções para acessar os logs da sua função.
## Transmissão de logs da função com o CloudWatch Logs Live Tail
O Amazon CloudWatch Logs Live Tail ajuda você a solucionar rapidamente problemas em suas funções ao exibir uma lista em tempo real de novos eventos de log diretamente no console do Lambda. É possível visualizar e filtrar logs ingeridos de suas funções do Lambda em tempo real, o que ajuda a detectar e a resolver problemas rapidamente.
**nota**
As sessões Live Tail acumulam custos por tempo de uso da sessão, por minuto. Para obter mais informações sobre a definição de preço, consulte [Preços do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
### Comparação entre Live Tail e --log-type Tail
Existem várias diferenças entre o CloudWatch Logs Live Tail e a opção [LogType: Tail](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html#lambda-Invoke-request-LogType) na API do Lambda (`--log-type Tail` na AWS CLI):
+ O `--log-type Tail` retorna somente os primeiros 4 KB dos logs de invocação. O Live Tail não tem esse limite e pode receber até 500 eventos de log por segundo.
+ O `--log-type Tail` captura e envia os logs com a resposta, o que pode impactar a latência de resposta da função. O Live Tail não afeta a latência de resposta da função.
+ O `--log-type Tail` fornece suporte apenas invocações síncronas. O Live Tail funciona para invocações síncronas e assíncronas.
**nota**
As [instâncias gerenciadas do Lambda](lambda-managed-instances.md) não oferecem suporte à opção `--log-type Tail`. Use o CloudWatch Logs Live Tail ou consulte o CloudWatch Logs diretamente para visualizar os logs das funções de instâncias gerenciadas.
### Permissões
As seguintes permissões são necessárias para iniciar e interromper as sessões do CloudWatch Logs Live Tail:
+ `logs:DescribeLogGroups`
+ `logs:StartLiveTail`
+ `logs:StopLiveTail`
### Inicialização de uma sessão do Live Tail no console do Lambda
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.
1. Escolha o nome da função.
1. Selecione a guia **Testar**.
1. No painel **Evento de teste**, escolha **CloudWatch Logs Live Tail**.
1. Em **Selecionar o grupo de logs**, o grupo de logs da função é selecionado por padrão. É possível selecionar até cinco grupos de logs ao mesmo tempo.
1. (Opcional) Para exibir apenas eventos de log que contenham determinadas palavras ou outras strings, insira a palavra ou string na caixa de texto **Adicionar padrões de filtro**. Os filtros diferenciam maiúsculas de minúsculas. É possível incluir múltiplos termos e operadores de padrão neste campo, incluindo expressões regulares (regex). Para obter mais informações sobre a sintaxe de padrões, consulte [Filter pattern syntax](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html) no *Guia do usuário do Amazon CloudWatch Logs*.
1. Escolha **Iniciar**. Os eventos de log correspondentes começam a aparecer na janela.
1. Para interromper a sessão Live Tail, escolha **Parar**.
**nota**
A sessão do Live Tail é encerrada automaticamente após 15 minutos de inatividade ou quando a sessão do console do Lambda expira.
## Acesse os logs da função usando o console.
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.
1. Selecione uma função.
1. Escolha a guia **Monitor** (Monitorar).
1. Escolha **Visualizar logs do CloudWatch** para abrir o console do CloudWatch.
1. Role para baixo e selecione o **Fluxo de logs** para as invocações da função que você deseja verificar.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/log-stream.png)
Cada instância de uma função do Lambda tem um fluxo de logs dedicado. Se uma função for escalada, cada instância simultânea terá seu próprio fluxo de logs. Cada vez que um novo ambiente de execução é criado em resposta a uma invocação, isso gera um novo fluxo de registro. A convenção de nomenclatura para fluxos de logs é:
```
YYYY/MM/DD[Function version][Execution environment GUID]
```
Um único ambiente de execução grava no mesmo fluxo de logs durante sua vida útil. O fluxo de logs contém mensagens desse ambiente de execução, bem como qualquer saída do código da sua função do Lambda. Cada mensagem tem um registro de data e hora, incluindo logs personalizados. Mesmo que sua função não registre nenhuma saída do seu código em log, há três instruções de log mínimas geradas por invocação (START, END e REPORT):
![\[monitoramento e observabilidade figura 3\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/monitoring-observability-figure-3.png)
Esses logs mostram:
+ **RequestId**: um ID exclusivo gerado por solicitação. Se a função do Lambda tentar novamente uma solicitação, esse ID não será alterado e aparecerá nos logs de cada nova tentativa subsequente.
+ **Início/Término₢**: marcam uma única invocação, de modo que cada linha de log entre eles pertence à mesma invocação.
+ **Duração**: o tempo total da invocação da função do manipulador, excluindo o código `INIT`.
+ **Duração faturada**: aplica a lógica de arredondamento para fins de cobrança.
+ **Tamanho da memória**: a quantidade de memória alocada para a função.
+ **Memória máxima usada**: o valor máximo de memória usada durante a invocação.
+ **Duração da inicialização**: o tempo gasto para executar a seção `INIT` do código, fora do manipulador principal.
## Acesso aos logs com a 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 concluir as etapas desta seção, você deve ter a [versão 2 da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
É possível usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) 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.
**Example 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"
}
```
**Example 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) 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](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Os usuários do macOS precisam usar `base64 -D`.
**Example 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`.
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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) no *Guia do usuário da AWS Command Line Interface versão 2*.
```
#!/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
```
**Example 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
```
**Example 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"
}
```
## Análise de logs e registro estruturado em logs
Com o CloudWatch Logs Insights, você pode pesquisar e analisar dados de log usando uma [sintaxe de consulta](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) especializada. Ele realiza consultas em vários grupos de logs e fornece uma filtragem poderosa usando a correspondência de padrões [glob](https://en.wikipedia.org/wiki/Glob_(programming)) e [expressões regulares](https://en.wikipedia.org/wiki/Regular_expression).
É possível aproveitar esses recursos implementando o registro estruturado em suas funções do Lambda. O registro estruturado organiza seus logs em um formato predefinido, facilitando assim a consulta. O uso de níveis de logs é uma primeira etapa importante na geração de logs fáceis de filtrar que separam mensagens informativas de avisos ou erros. Por exemplo, considere o código em Node.js a seguir:
```
exports.handler = async (event) => {
console.log("console.log - Application is fine")
console.info("console.info - This is the same as console.log")
console.warn("console.warn - Application provides a warning")
console.error("console.error - An error occurred")
}
```
O arquivo de log resultante do CloudWatch contém um campo separado que especifica o nível do log:
![\[monitoramento e observabilidade figura 10\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/monitoring-observability-figure-10.png)
Uma consulta do CloudWatch Logs Insights pode então filtrar por nível de log. Por exemplo, para consultar somente erros, é possível utilizar a consulta a seguir:
```
fields @timestamp, @message
| filter @message like /ERROR/
| sort @timestamp desc
```
### Registro de log estruturado em JSON
O JSON é comumente usado para fornecer estrutura para logs de aplicações. No exemplo a seguir, os logs foram convertidos em JSON de forma a gerar três valores distintos:
![\[monitoramento e observabilidade figura 11\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/monitoring-observability-figure-11.png)
O recurso CloudWatch Logs Insights descobre automaticamente valores na saída JSON e analisa as mensagens como campos, sem a necessidade de uma expressão regular ou glob personalizado. Usando os logs estruturados em JSON, a consulta a seguir encontra invocações em que o arquivo carregado era maior que 1 MB, o tempo de upload era superior a 1 segundo e a invocação não era uma inicialização a frio:
```
fields @message
| filter @message like /INFO/
| filter uploadedBytes > 1000000
| filter uploadTimeMS > 1000
| filter invocation != 1
```
Essa consulta pode produzir o seguinte resultado:
![\[monitoramento e observabilidade figura 12\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/monitoring-observability-figure-12.png)
Os campos descobertos em JSON são preenchidos automaticamente no menu *Campos descobertos* no lado direito. Os campos padrão emitidos pelo serviço Lambda são prefixados com “@” e você pode consultar esses campos da mesma forma. Os logs do Lambda sempre incluem os campos @timestamp, @logStream, @message, @requestId, @duration, @billedDuration, @type, @maxMemoryUsed, @memorySize. Se o X-Ray estiver habilitado para uma função, os logs também incluirão @xrayTraceId e @xraySegmentId.
Quando uma fonte de eventos da AWS, como o Amazon S3, o Amazon SQS ou o Amazon EventBridge, invoca sua função, o evento inteiro é fornecido à função como uma entrada de objeto JSON. Ao registrar esse evento na primeira linha da função, você pode consultar qualquer um dos campos aninhados usando o CloudWatch Logs Insights.
### Consultas úteis do Insights
A tabela a seguir mostra exemplos de consultas do Insights que podem ser úteis para monitorar funções do Lambda.
| Descrição | Exemplo de consulta e sintaxe do |
| --- | --- |
| Os últimos 100 erros |
```
fields Timestamp, LogLevel, Message
\| filter LogLevel == "ERR"
\| sort @timestamp desc
\| limit 100
``` |
| As 100 invocações mais faturadas |
```
filter @type = "REPORT"
\| fields @requestId, @billedDuration
\| sort by @billedDuration desc
\| limit 100
``` |
| Porcentagem de inicializações a frio no total de invocações |
```
filter @type = "REPORT"
\| stats sum(strcontains(@message, "Init Duration"))/count(*) * 100 as
coldStartPct, avg(@duration)
by bin(5m)
``` |
| Relatório percentual da duração do Lambda |
```
filter @type = "REPORT"
\| stats
avg(@billedDuration) as Average,
percentile(@billedDuration, 99) as NinetyNinth,
percentile(@billedDuration, 95) as NinetyFifth,
percentile(@billedDuration, 90) as Ninetieth
by bin(30m)
``` |
| Relatório percentual do uso de memória do Lambda |
```
filter @type="REPORT"
\| stats avg(@maxMemoryUsed/1024/1024) as mean_MemoryUsed,
min(@maxMemoryUsed/1024/1024) as min_MemoryUsed,
max(@maxMemoryUsed/1024/1024) as max_MemoryUsed,
percentile(@maxMemoryUsed/1024/1024, 95) as Percentile95
``` |
| Invocações que usam 100% da memória atribuída |
```
filter @type = "REPORT" and @maxMemoryUsed=@memorySize
\| stats
count_distinct(@requestId)
by bin(30m)
``` |
| Memória média usada em todas as invocações |
```
avgMemoryUsedPERC,
avg(@billedDuration) as avgDurationMS
by bin(5m)
``` |
| Visualização das estatísticas de memória |
```
filter @type = "REPORT"
\| stats
max(@maxMemoryUsed / 1024 / 1024) as maxMemMB,
avg(@maxMemoryUsed / 1024 / 1024) as avgMemMB,
min(@maxMemoryUsed / 1024 / 1024) as minMemMB,
(avg(@maxMemoryUsed / 1024 / 1024) / max(@memorySize / 1024 / 1024)) * 100 as avgMemUsedPct,
avg(@billedDuration) as avgDurationMS
by bin(30m)
``` |
| Invocações em que o Lambda foi encerrado |
```
filter @message like /Process exited/
\| stats count() by bin(30m)
``` |
| Invocações que atingiram o tempo limite |
```
filter @message like /Task timed out/
\| stats count() by bin(30m)
``` |
| Relatório de latência |
```
filter @type = "REPORT"
\| stats avg(@duration), max(@duration), min(@duration)
by bin(5m)
``` |
| Memória superprovisionada |
```
filter @type = "REPORT"
\| stats max(@memorySize / 1024 / 1024) as provisonedMemMB,
min(@maxMemoryUsed / 1024 / 1024) as smallestMemReqMB,
avg(@maxMemoryUsed / 1024 / 1024) as avgMemUsedMB,
max(@maxMemoryUsed / 1024 / 1024) as maxMemUsedMB,
provisonedMemMB - maxMemUsedMB as overProvisionedMB
``` |
## Exibição de logs e painéis
Para qualquer consulta do CloudWatch Logs Insights, é possível exportar os resultados para o formato de markdown ou CSV. Em alguns casos, talvez seja mais útil criar [visualizações a partir de consultas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_Insights-Visualizing-Log-Data.html), desde que haja pelo menos uma função de agregação. A função `stats` permite definir agregações e agrupamentos.
O exemplo anterior de *logInsightsJSON* filtrou o tamanho e o tempo de upload e excluiu as primeiras invocações. Isso resultou em uma tabela de dados. Para monitorar um sistema de produção, pode ser mais útil visualizar os tamanhos mínimo, máximo e médio dos arquivos para encontrar valores discrepantes. Para fazer isso, aplique a função de estatísticas com os agregados necessários e agrupe em um valor de tempo, como a cada minuto:
Por exemplo, considere a seguinte consulta. Este é o mesmo exemplo de consulta da seção [Registro de log estruturado em JSON](#querying-logs-json), mas com funções adicionais de agregação:
```
fields @message
| filter @message like /INFO/
| filter uploadedBytes > 1000000
| filter uploadTimeMS > 1000
| filter invocation != 1
| stats min(uploadedBytes), avg(uploadedBytes), max(uploadedBytes) by bin (1m)
```
Incluímos esses agregados porque pode ser mais útil visualizar os tamanhos mínimo, máximo e médio dos arquivos a fim de encontrar valores atípicos. É possível ver os resultados na guia **Visualização**:
![\[monitoramento e observabilidade figura 14\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/monitoring-observability-figure-14.png)
Depois de concluir a criação da visualização, você pode, opcionalmente, adicionar o gráfico a um painel do CloudWatch. Para fazer isso, escolha **Adicionar ao painel** acima da visualização. Isso adiciona a consulta como um widget e permite selecionar intervalos de atualização automática, facilitando o monitoramento contínuo dos resultados:
![\[monitoramento e observabilidade figura 15\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/monitoring-observability-figure-15.png)