.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrai os campos `loggingTime`, `loggingType` e `loggingMessage`, aplica o filtro para eventos de logs que contêm strings `ERROR` ou `INFO` e exibe apenas os campos `loggingMessage` e `loggingType` para eventos que contêm uma string `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# sort
Use `sort` para exibir eventos de log em ordem crescente (`asc`) ou decrescente (`desc`) por um campo especificado. Use-o com o comando `limit` para criar consultas de “N principais” ou “N inferiores”.
O algoritmo de classificação é uma versão atualizada da classificação natural. Se você classificar em ordem crescente, a lógica a seguir será usada.
+ Todos os valores não numéricos vêm antes de todos os valores numéricos. *Valores numéricos* são valores que só incluem números, não uma mistura de números e outros caracteres.
+ Para valores não numéricos, o algoritmo agrupa caracteres numéricos consecutivos e caracteres alfabéticos consecutivos em blocos separados para comparação. Ele ordena as partes não numéricas pelos valores Unicode e as partes numéricas primeiro pelo tamanho e depois pelo valor numérico.
Para obter mais informações sobre a ordem Unicode, consulte [Lista de caracteres Unicode](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Por exemplo, o resultado a seguir é classificado na ordem crescente.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sorted by unicode order
#
*%04
0# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Alphanumeric starting with numbers
5A
111A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starts with more digits than 5A, so it sorted to be later than 5A
2345_
@ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2345 is compared with @ in the unicode order,
@_
A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Values starting with letters
A9876fghj
a12345hfh
0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number values
01
1
2
3
```
Se você classificar na ordem decrescente, os resultados da classificação serão invertidos.
Por exemplo, a consulta a seguir de logs de fluxo da Amazon VPC localiza as 15 principais transferências de pacotes entre hosts.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# stats
Use `stats` para criar visualizações dos seus dados de log, como gráficos de barras, gráficos de linhas e gráficos de áreas empilhadas. Isso ajuda você a identificar padrões em seus dados de registro com mais eficiência. CloudWatch O Logs Insights gera visualizações para consultas que usam a `stats` função e uma ou mais funções de agregação.
Por exemplo, a consulta a seguir em um grupo de logs do Route 53 retorna visualizações que mostram a distribuição dos registros do Route 53 por hora, por tipo de consulta.
```
stats count(*) by queryType, bin(1h)
```
Todas essas consultas podem produzir gráficos de barras. Se sua consulta usar a função `bin()` para agrupar os dados por um campo ao longo do tempo, você também poderá ver gráficos de linhas e gráficos de áreas empilhadas.
As unidades e abreviações de tempo a seguir são compatíveis com a função `bin`. Para todas as unidades e abreviações que incluem mais de um caractere, é permitido adicionar "s" para formar o plural. Assim, ambos `hr` e `hrs` funcionam para especificar horas.
+ `millisecond` `ms` `msec`
+ `second` `s` `sec`
+ `minute` `m` `min`
+ `hour` `h` `hr`
+ `day` `d`
+ `week` `w`
+ `month` `mo` `mon`
+ `quarter` `q` `qtr`
+ `year` `y` `yr`
**Topics**
+ [Visualizar dados de séries temporais](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualizar dados de log agrupados por campos](#CWL_Insights-Visualizing-ByFields)
+ [Use vários comandos de estatísticas em uma única consulta](#CWL_QuerySyntax-stats-multi)
+ [Funções para uso com estatísticas](#CWL_QuerySyntax-stats-functions)
## Visualizar dados de séries temporais
As visualizações de séries temporais funcionam para consultas com as seguintes características:
+ A consulta contém uma ou mais funções de agregação. Para obter mais informações, consulte [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ A consulta usa a função `bin()` para agrupar os dados por um campo.
Essas consultas podem produzir gráficos de linha, gráficos de áreas empilhadas, gráficos de barras e gráficos de pizza.
**Exemplos**
Para obter um tutorial completo, consulte [Tutorial: Executar uma consulta que produz uma visualização de séries temporais](CWL_AnalyzeLogData_VisualizationQuery.md).
Aqui estão mais exemplos de consultas que funcionam para visualização de séries temporais.
A consulta a seguir gera uma visualização dos valores médios do campo `myfield1`, com um ponto de dados criado a cada cinco minutos. Cada ponto de dados é a agregação das médias dos valores `myfield1` dos logs dos últimos cinco minutos.
```
stats avg(myfield1) by bin(5m)
```
A consulta a seguir gera uma visualização dos três valores com base em campos diferentes, com um ponto de dados criado a cada cinco minutos. A visualização é gerada porque a consulta contém funções de agregação e usa `bin()` como o campo de agrupamento.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Restrições do gráfico de linhas e do gráfico de áreas empilhadas**
Consultas que agregam informações de entrada de log, mas que não usam a função `bin()`, podem gerar gráficos de barras. No entanto, as consultas não podem gerar gráficos de linha ou gráficos de áreas empilhadas. Para obter mais informações sobre esses tipos de políticas, consulte [Visualizar dados de log agrupados por campos](#CWL_Insights-Visualizing-ByFields).
## Visualizar dados de log agrupados por campos
É possível produzir gráficos de barras para consultas que usam a função `stats` e uma ou mais funções de agregação. Para obter mais informações, consulte [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Para ver a visualização, execute sua consulta. Depois, escolha a guia **Visualization**(Visualização), selecione a seta ao lado de **Line**(Linha) e escolha **Bar**(Barra). As visualizações estão limitadas a até 100 barras no gráfico de barras.
**Exemplos**
Para obter um tutorial completo, consulte [Tutorial: Executar uma consulta que produz uma visualização agrupada por campos de log](CWL_AnalyzeLogData_VisualizationFieldQuery.md). Os parágrafos a seguir incluem mais consultas de exemplo para a visualização por campos.
A consulta de log de fluxo da VPC a seguir localiza o número médio de bytes transferidos por sessão para cada endereço de destino.
```
stats avg(bytes) by dstAddr
```
Também é possível produzir um gráfico que inclua mais de uma barra para cada valor resultante. Por exemplo, a consulta de log de fluxo da VPC a seguir localiza o número médio e máximo de bytes transferidos por sessão para cada endereço de destino.
```
stats avg(bytes), max(bytes) by dstAddr
```
A consulta a seguir localiza o número de logs de consulta do Amazon Route 53 para cada tipo de consulta.
```
stats count(*) by queryType
```
## Use vários comandos de estatísticas em uma única consulta
Você pode usar até dois comandos `stats` em uma única consulta. Isso permite executar uma agregação adicional na saída da primeira agregação.
**Exemplo: consulta com dois comandos `stats`**
Por exemplo, a consulta a seguir localiza primeiro o volume total de tráfego em compartimentos de cinco minutos e, em seguida, calcula o volume de tráfego mais alto, mais baixo e médio entre esses compartimentos de cinco minutos.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length)/1024/1024 as logs_mb BY bin(5m)
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb
```
**Exemplo: combine vários comandos de estatísticas com outras funções, como `filter`, `fields` e `bin`**
Você pode combinar dois comandos `stats` com outros comandos, como `filter` e `fields`, em uma única consulta. Por exemplo, a consulta a seguir localiza o número de endereços IP distintos nas sessões e localiza o número de sessões por plataforma do cliente, filtra esses endereços IP e, por fim, localiza a média de solicitações de sessão por plataforma do cliente.
```
STATS count_distinct(client_ip) AS session_ips,
count(*) AS requests BY session_id, client_platform
| FILTER session_ips > 1
| STATS count(*) AS multiple_ip_sessions,
sum(requests) / count(*) AS avg_session_requests BY client_platform
```
Você pode usar as funções `bin` e `dateceil` em consultas com vários comandos `stats`. Por exemplo, a consulta a seguir primeiro combina mensagens em blocos de cinco minutos, depois agrega esses blocos de cinco minutos em blocos de dez minutos e calcula os volumes de tráfego mais altos, mais baixos e médios dentro de cada bloco de dez minutos.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) / 1024 / 1024 AS logs_mb BY BIN(5m) as @t
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb BY dateceil(@t, 10m)
```
**Observações e limitações**
Uma consulta pode ter no máximo dois comandos `stats`. Não é possível alterar esta cota.
Se você usar um comando `sort` ou `limit`, ele deverá aparecer após o segundo comando `stats`. Se estiver antes do segundo comando `stats`, a consulta não é válida.
Quando uma consulta tem dois comandos `stats`, a exibição dos resultados parciais da consulta só começará quando a primeira agregação `stats` for concluída.
No segundo comando `stats` de uma única consulta, você pode se referir somente aos campos definidos no primeiro comando `stats`. Por exemplo, a consulta a seguir não é válida porque o campo `@message` não estará disponível após a primeira agregação `stats`.
```
FIELDS @message
| STATS SUM(Fault) by Operation
# You can only reference `SUM(Fault)` or Operation at this point
| STATS MAX(strlen(@message)) AS MaxMessageSize # Invalid reference to @message
```
Todos os campos que você referenciar após o primeiro comando `stats` devem ser definidos nesse primeiro comando `stats`.
```
STATS sum(x) as sum_x by y, z
| STATS max(sum_x) as max_x by z
# You can only reference `max(sum_x)`, max_x or z at this point
```
**Importante**
A função `bin` sempre usa implicitamente o campo `@timestamp`. Isso significa que você não pode usar `bin` no segundo comando `stats` sem usar o primeiro comando `stats` para propagar o campo `timestamp`. Por exemplo, a consulta a seguir não é válida.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes BY @logStream
| STATS avg(ingested_bytes) BY bin(5m) # Invalid reference to @timestamp field
```
Em vez disso, defina o campo `@timestamp` no primeiro comando `stats` e, em seguida, você poderá usá-lo com `dateceil` no segundo comando `stats`, como no exemplo a seguir.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes, max(@timestamp) as @t BY @logStream
| STATS avg(ingested_bytes) BY dateceil(@t, 5m)
```
## Funções para uso com estatísticas
CloudWatch O Logs Insights suporta funções de agregação de estatísticas e funções de não agregação de estatísticas.
Use funções de agregação de estatísticas no comando `stats` e como argumentos de outras funções.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | número | A média dos valores no campo especificado. |
| `count()` `count(fieldName: LogField)` | número | Faz a contagem dos eventos de log. `count()` (ou `count(*)`) conta todos os eventos retornados pela consulta, e o `count(fieldName)` conta todos os registros que incluam o nome do campo especificado. |
| `count_distinct(fieldName: LogField)` | número | Retorna o número de valores exclusivos do campo. Se o campo tiver cardinalidade muito alta (muitos valores exclusivos), o valor retornado por `count_distinct` será apenas uma aproximação. |
| `max(fieldName: LogField)` | LogFieldValue | O máximo dos valores desse campo de log nos logs consultados. |
| `min(fieldName: LogField)` | LogFieldValue | O mínimo dos valores desse campo de log nos logs consultados. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Um percentil indica a posição relativa de um valor no conjunto de dados. Por exemplo, `pct(@duration, 95)` retorna o valor `@duration` em que 95% dos valores de `@duration` são menores que esse valor e 5% são maiores que esse valor. |
| `stddev(fieldName: NumericLogField)` | número | O desvio padrão dos valores no campo especificado. |
| `sum(fieldName: NumericLogField)` | número | A soma dos valores no campo especificado. |
**Funções de estatísticas de não agregação**
Use funções de não agregação no comando `stats` e como argumentos de outras funções.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Retorna o valor de `fieldName` do evento do log que tem o primeiro time stamp nos logs consultados. |
| `latest(fieldName: LogField)` | LogField | Retorna o valor de `fieldName` do evento do log que tem o último time stamp nos logs consultados. |
| `sortsFirst(fieldName: LogField)` | LogField | Retorna o valor do `fieldName` que aparece em primeiro lugar nos logs consultados. |
| `sortsLast(fieldName: LogField)` | LogField | Retorna o valor do `fieldName` que aparece em último lugar nos logs consultados. |
# limite
Use `limit` para especificar o número de eventos de log que você deseja que sua consulta retorne. Se você omitir `limit`, a consulta retornará até 10.000 eventos de log nos resultados.
Por exemplo, o exemplo a seguir retorna apenas os 25 eventos de log mais recentes
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Use `dedup` para remover resultados duplicados com base em valores específicos em campos que você especifica. É possível usar `dedup` com um ou mais campos. Se você especificar um campo com `dedup`, apenas um evento de log será retornado para cada valor exclusivo desse campo. Se especificar vários campos, um evento de log será retornado para cada combinação exclusiva de valores desses campos.
As duplicatas serão descartadas em ordem de classificação, e apenas o primeiro resultado dessa ordem será mantido. Convém classificar os resultados antes de os submeter ao comando `dedup`. Se os resultados não forem classificados antes de serem executados por `dedup`, a ordem de classificação decrescente padrão `@timestamp` será usada.
Valores nulos não são considerados duplicatas para avaliação. Eventos de log com valores nulos para qualquer um dos campos especificados são mantidos. Para eliminar campos com valores nulos, use **`filter`** com a função `isPresent(field)`.
O único comando de consulta que você pode usar em uma consulta após o comando `dedup` é `limit`.
Quando você usa `dedup` em uma consulta, o console exibe uma mensagem como **Mostrar registros X de Y**, em que X é o número de resultados desduplicados e Y é o número total de registros correspondidos antes da desduplicação. Isso indica que os registros duplicados foram removidos e não significa que faltam dados.
**Exemplo: visualizar somente o evento de log mais recente de cada valor exclusivo do campo chamado `server`**
O exemplo a seguir mostra os campos `timestamp`, `server`, `severity` e `message` somente para o evento mais recente de cada valor exclusivo de `server`.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Para ver mais exemplos de consultas do CloudWatch Logs Insights, consulte[Consultas gerais](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general).
# unmask
Use `unmask` para exibir todo o conteúdo de um evento de log que tenha algum conteúdo mascarado devido à política de proteção de dados. Para usar este comando, você deve ter a permissão `logs:Unmask`.
Para mais informações sobre a proteção de dados nos grupos de logs, acesse [Ajude a proteger dados de log confidenciais com mascaramento](mask-sensitive-log-data.md).
# unnest
Use `unnest` para nivelar uma lista usada como entrada para gerar vários registros com um único registro para cada elemento na lista. Com base no número de itens que um campo contém, esse comando descarta o registro atual e gera novos registros. Cada registro inclui o `unnested_field`, que representa um item. Todos os outros campos vêm do registro original.
A entrada para `unnest` é `LIST`, que vem da função `jsonParse`. Para obter mais informações, consulte [Tipos de estrutura](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Quaisquer outros tipos, como `MAP`, `String` e `numbers`, são tratados como uma lista com um item no `unnest`.
**Estrutura do comando**
O exemplo a seguir descreve o formato desse comando.
```
unnest field into unnested_field
```
**Consulta de exemplo**
O exemplo a seguir analisa uma string de objeto JSON e expande uma lista de eventos de campo.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
O evento de logs para essa consulta de exemplo pode ser uma string JSON da seguinte forma:
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
Nesse caso, a consulta de amostra produz dois registros no resultado da consulta, um com `event.name` como `exception` e outro com `event.name` como **ação do usuário**.
**Consulta de exemplo**
O exemplo a seguir nivela uma lista e depois filtra os itens.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Consulta de exemplo**
O exemplo a seguir nivela uma lista para agregação.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# lookup
Use `lookup` para enriquecer os resultados da consulta com dados de referência de uma tabela de pesquisa. Uma tabela de pesquisa contém dados CSV que você carrega para o Amazon CloudWatch Logs. Quando uma consulta é executada, o `lookup` comando combina um campo em seus eventos de log com um campo na tabela de pesquisa e acrescenta os campos de saída especificados aos resultados.
Use tabelas de pesquisa para cenários de enriquecimento de dados, como mapear detalhes do usuário IDs para o usuário, códigos do produto para informações do produto ou códigos de erro para descrições de erros.
## Criação e gerenciamento de tabelas de pesquisa
Antes de usar o `lookup` comando em uma consulta, você deve criar uma tabela de pesquisa. Você pode criar e gerenciar tabelas de pesquisa a partir do CloudWatch console ou usando a API Amazon CloudWatch Logs.
**Para criar uma tabela de pesquisa (console)**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Configurações** e, em seguida, escolha a guia **Registros**.
1. Role até **Pesquisar tabelas** e escolha **Gerenciar**.
1. Escolha **Criar tabela de pesquisa**.
1. Insira um nome para a tabela de pesquisa. O nome só pode conter caracteres alfanuméricos, hífens e sublinhados.
1. (Opcional) Insira uma descrição.
1. Faça upload de um arquivo CSV. O arquivo deve incluir uma linha de cabeçalho com nomes de colunas, usar a codificação UTF-8 e não exceder 10 MB.
1. (Opcional) Especifique uma AWS KMS chave para criptografar os dados da tabela.
1. Escolha **Criar**.
Depois de criar uma tabela de pesquisa, você pode visualizá-la no editor de consultas do CloudWatch Logs Insights. Escolha a guia **Pesquisar tabelas** para procurar tabelas disponíveis e seus campos.
Para atualizar uma tabela de pesquisa, selecione a tabela e escolha **Ações**, **Atualizar**. Faça upload de um novo arquivo CSV para substituir todo o conteúdo existente. Para excluir uma tabela de pesquisa, escolha **Ações**, **Excluir**.
**nota**
Você pode criar até 100 tabelas de pesquisa por conta por Região da AWS. Os arquivos CSV podem ter até 10 MB. Você também pode gerenciar tabelas de pesquisa usando a API Amazon CloudWatch Logs. Para obter mais informações, consulte [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)a *Referência da API Amazon CloudWatch Logs*.
**nota**
Se a tabela de pesquisa for criptografada com uma chave KMS, o chamador deverá ter a `kms:Decrypt` permissão na chave (a chave KMS usada para criptografar a tabela de pesquisa) para usar a `StartQuery` API com uma consulta que faça referência a essa tabela de pesquisa. Para obter mais informações, consulte [Criptografe tabelas de pesquisa em CloudWatch registros usando AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Sintaxe de consulta para pesquisa
**Estrutura do comando**
O seguinte mostra o formato desse comando.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
O comando usa os seguintes argumentos:
+ `table`— O nome da tabela de pesquisa a ser usada.
+ `lookup-field`— O campo na tabela de pesquisa a ser comparado.
+ `log-field`— O campo em seu registro de eventos correspondente. A correspondência é exata e diferencia maiúsculas de minúsculas.
+ `output-mode`— Especifique `OUTPUT` para adicionar os campos de saída aos resultados. Se um campo com o mesmo nome já existir no evento de log, ele será substituído.
+ `output-field`— Um ou mais campos da tabela de pesquisa para adicionar aos resultados.
**Exemplo: enriqueça eventos de registro com detalhes do usuário**
Suponha que você tenha um grupo de registros com eventos que contêm um `id` campo e uma tabela de pesquisa chamada `user_data` com colunas `id` `name``email`,, `department` e. A consulta a seguir enriquece cada evento de log com o nome do usuário, e-mail e departamento da tabela de pesquisa.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Exemplo: Use a pesquisa com agregação**
Você pode usar campos de saída de pesquisa com funções de agregação. A consulta a seguir enriquece os eventos de log com detalhes do usuário e, em seguida, conta os eventos agrupados por endereço de e-mail.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Exemplo: Use a pesquisa com filtro**
Você pode filtrar os resultados com base nos campos retornados pela pesquisa. A consulta a seguir enriquece os eventos de registro e depois filtra para mostrar somente os eventos de um departamento específico.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Funções booleanas, de comparação, numéricas e de data e hora, entre outras
CloudWatch O Logs Insights oferece suporte a muitas outras operações e funções em consultas, conforme explicado nas seções a seguir.
**Topics**
+ [Operadores aritméticos](#CWL_QuerySyntax-operations-arithmetic)
+ [Operadores booleanos](#CWL_QuerySyntax-operations-Boolean)
+ [Operadores de comparação](#CWL_QuerySyntax-operations-comparison)
+ [Operadores numéricos](#CWL_QuerySyntax-operations-numeric)
+ [Tipos de estrutura](#CWL_QuerySyntax-structure-types)
+ [Funções de data e hora](#CWL_QuerySyntax-datetime)
+ [Funções gerais](#CWL_QuerySyntax-general-functions)
+ [Funções JSON](#CWL_QuerySyntax-json-functions)
+ [Funções de string de endereço IP](#CWL_QuerySyntax-IPaddress-functions)
+ [Funções de string](#CWL_QuerySyntax-string-functions)
## Operadores aritméticos
Os operadores aritméticos aceitam tipos de dados numéricos como argumentos e retornam resultados numéricos. Use operadores aritméticos nos comandos `filter` e `fields` e como argumentos de outras funções.
| Operation | Description |
| --- | --- |
| `a + b` | Adição |
| `a - b` | Subtração |
| `a * b` | Multiplicação |
| `a / b` | Divisão |
| `a ^ b` | Exponenciação (`2 ^ 3` retorna `8`) |
| `a % b` | Resto ou módulo (`10 % 3` retorna `1`) |
## Operadores booleanos
Use os operadores booleanos `and`, `or` e `not`.
**nota**
Use operadores booleanos somente em funções que retornam um valor de **TRUE** ou **FALSE**.
## Operadores de comparação
Os operadores de comparação aceitam todos os tipos de dados como argumentos e retornam um resultado booliano. Use operadores de comparação no comando `filter` e como argumentos de outras funções.
| Operador | Description |
| --- | --- |
| `=` | Equal |
| `!=` | Not equal |
| `<` | Menor que |
| `>` | Maior que |
| `<=` | Menor ou igual a |
| `>=` | Maior ou igual a |
## Operadores numéricos
As operações numéricas aceitam tipos de dados numéricos como argumentos e retornam resultados numéricos. Use operadores numéricos nos comandos `filter` e `fields` e como argumentos de outras funções.
| Operation | Tipo de resultado | Description |
| --- | --- | --- |
| `abs(a: number)` | número | Valor absoluto |
| `ceil(a: number)` | número | Arredonde para o máximo (o menor inteiro maior que o valor de `a`) |
| `floor(a: number)` | número | Arredonde para o mínimo (o maior inteiro menor que o valor de `a`) |
| `greatest(a: number, ...numbers: number[])` | número | Retorna o maior valor |
| `least(a: number, ...numbers: number[])` | número | Retorna o menor valor |
| `log(a: number)` | número | Log natural |
| `sqrt(a: number)` | número | Raiz quadrada |
## Tipos de estrutura
Um mapa ou lista é um tipo de estrutura no CloudWatch Logs Insights que permite acessar e usar atributos para consultas.
**Exemplo: para obter um mapa ou uma lista**
Use `jsonParse` para analisar um campo que é uma string json em um mapa ou uma lista.
```
fields jsonParse(@message) as json_message
```
**Exemplo: para acessar atributos**
Use o operador de acesso por ponto (map.attribute) para acessar itens em um mapa. Se um atributo em um mapa contiver caracteres especiais, use crases para delimitar o nome do atributo (map.attributes). `special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Use o operador de acesso por colchetes (list[index]) para recuperar um item em uma posição específica na lista.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Coloque caracteres especiais entre crases (``) quando caracteres especiais estiverem presentes no nome da chave.
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Exemplo: resultados vazios**
Mapas e listas são tratados como nulos para funções de string, número e data e hora.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
A comparação do mapa e da lista com quaisquer outros campos resulta em `false`.
**nota**
O uso de mapa e lista em `dedup`, `pattern`, `sort` e `stats` não é suportado.
## Funções de data e hora
**Funções de data e hora**
Use funções de data e hora nos comandos `fields` e `filter` e como argumentos de outras funções. Use essas funções para criar buckets de tempo para consultas com funções de agregação. Use períodos que consistam em um número e uma das seguintes abreviaturas:
+ `ms` para milissegundos
+ `s` para segundos
+ `m` para minutos
+ `h` para horas
Por exemplo, `10m` é 10 minutos, e `1h` é uma hora.
**nota**
Use a unidade de tempo mais apropriada para a função de data e hora. CloudWatch Os registros limitam sua solicitação de acordo com a unidade de tempo que você escolher. Por exemplo, o limite máximo será 60 para qualquer solicitação que use `s`. Então, se você especificar`bin(300s)`, o CloudWatch Logs realmente implementa isso como 60 segundos, porque 60 é o número de segundos em um minuto, então o CloudWatch Logs não usará um número maior que 60 com`s`. Para criar um bucket de 5 minutos, use `bin(5m)` em vez disso.
O limite para `ms` é 1.000, o limite para `s` e `m` é 60 e o limite para `h` é 24.
A tabela a seguir contém uma lista das diferentes funções de data e hora que você pode usar nos comandos de consulta. A tabela lista o tipo de resultado de cada função e contém uma descrição de cada função.
**dica**
Quando você cria um comando de consulta, é possível usar o seletor de intervalo de tempo para selecionar um período que deseja consultar. Por exemplo, você pode definir um período entre intervalos de 5 e 30 minutos; intervalos de 1, 3 e 12 horas; ou um período personalizado. Você também pode definir períodos entre datas específicas.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `bin(period: Period)` | Timestamp | Arredonda o valor de `@timestamp` para o período indicado e trunca. Por exemplo, `bin(5m)` arredonda o valor de `@timestamp` para os 5 minutos mais próximos. Você pode usar isso para agrupar várias entradas de log em uma consulta. O seguinte exemplo conta a quantidade de exceções por hora: filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
As unidades e abreviações de tempo a seguir são compatíveis com a função `bin`. Para todas as unidades e abreviações que incluem mais de um caractere, é permitido adicionar "s" para formar o plural. Assim, ambos `hr` e `hrs` funcionam para especificar horas. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Timestamp | Trunca o time stamp para o período indicado. Por exemplo, `datefloor(@timestamp, 1h)` trunca todos os valores de `@timestamp` no final. |
| `dateceil(timestamp: Timestamp, period: Period)` | Timestamp | Arredonda o time stamp para o período indicado e trunca. Por exemplo, `dateceil(@timestamp, 1h)` trunca todos os valores de `@timestamp` no início. |
| `fromMillis(fieldName: number)` | Timestamp | Interpreta o campo de entrada como o número de milissegundos desde a epoch do Unix e o converte em um time stamp. |
| `toMillis(fieldName: Timestamp)` | número | Converte o time stamp encontrado no campo nomeado em um número que representa os milissegundos desde a epoch do Unix. Por exemplo, `toMillis(@timestamp)` converte o carimbo de data/hora `2022-01-14T13:18:031.000-08:00` para `1642195111000`. |
| `now()` | número | Retorna a hora em que o processamento da consulta foi iniciado, em segundos de época. Essa função não usa argumentos. Você pode usá-la para filtrar os resultados da consulta de acordo com a hora atual. Por exemplo, a consulta a seguir gera todos os erros 4xx das últimas duas horas: parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
O exemplo a seguir retorna todas as entradas de log das últimas cinco horas que contêm a palavra `error` ou `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**nota**
Atualmente, o CloudWatch Logs Insights não oferece suporte à filtragem de registros com carimbos de data/hora legíveis por humanos.
## Funções gerais
**Funções gerais**
Use funções gerais nos comandos `fields` e `filter` e como argumentos de outras funções.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Booleano | Retorna `true` se o campo existir |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Retorna o primeiro valor não nulo da lista |
## Funções JSON
**Funções JSON**
Use funções JSON nos comandos `fields` e `filter` como argumentos de outras funções.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Mapa \$1 Lista \$1 Vazio | Retorna um mapa ou uma lista quando a entrada é uma representação de string do objeto JSON ou de uma matriz JSON. Retorna um valor vazio, se a entrada não for uma das representações. |
| `jsonStringify(fieldName: Map \| List)` | String | Retorna uma string JSON de um mapa ou dados da lista. |
## Funções de string de endereço IP
**Funções de string de endereço IP**
Use funções de string no endereço IP dos comandos `filter` e `fields` e como argumentos de outras funções.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | booliano | Retorna `true` se o campo for um IPv6 endereço válido IPv4 ou. |
| `isValidIpV4(fieldName: string)` | booleano | Retorna `true` se o campo for um IPv4 endereço válido. |
| `isValidIpV6(fieldName: string)` | booleano | Retorna `true` se o campo for um IPv6 endereço válido. |
| `isIpInSubnet(fieldName: string, subnet: string)` | booleano | Retorna `true` se o campo for um IPv6 endereço válido IPv4 ou dentro da sub-rede v4 ou v6 especificada. Ao especificar a sub-rede, use a notação CIDR, como `192.0.2.0/24` ou `2001:db8::/32`, onde `192.0.2.0` ou`2001:db8::` é o início do bloco CIDR. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | booleano | Retorna `true` se o campo for um IPv4 endereço válido dentro da sub-rede v4 especificada. Ao especificar a sub-rede, use a notação CIDR, como `192.0.2.0/24`, em que `192.0.2.0` é o início do bloco CIDR. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | booleano | Retorna `true` se o campo for um IPv6 endereço válido dentro da sub-rede v6 especificada. Ao especificar a sub-rede, use a notação CIDR, como `2001:db8::/32`, em que `2001:db8::` é o início do bloco CIDR. |
## Funções de string
**Funções de string**
Use funções de string nos comandos `fields` e `filter` e como argumentos de outras funções.
| Função | Tipo de resultado | Description |
| --- | --- | --- |
| `isempty(fieldName: string)` | Número | Retornará `1` se o campo não for encontrado ou for uma string vazia. |
| `isblank(fieldName: string)` | Número | Retornará `1` se o campo não for encontrado, for uma string vazia ou só contiver espaço branco. |
| `concat(str: string, ...strings: string[])` | string | Concatena as strings. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | string | Se a função não tiver um segundo argumento, ela removerá os caracteres em branco da esquerda da string. Se a função tiver um segundo argumento de string, ela não removerá os caracteres em branco. Em vez disso, remove os caracteres em `trimChars` à esquerda de `str`. Por exemplo, `ltrim("xyZxyfooxyZ","xyZ")` exibe `"fooxyZ"`. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | string | Se a função não tiver um segundo argumento, ela removerá os caracteres em branco da direita da string. Se a função tiver um segundo argumento de string, ela não removerá os caracteres em branco. Em vez disso, remove os caracteres de `trimChars` à direita de `str`. Por exemplo, `rtrim("xyZfooxyxyZ","xyZ")` exibe `"xyZfoo"`. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | string | Se a função não tiver um segundo argumento, ela removerá os caracteres em branco nas duas extremidades da string. Se a função tiver um segundo argumento de string, ela não removerá os caracteres em branco. Em vez disso, remove os caracteres de `trimChars` de ambos os lados de `str`. Por exemplo, `trim("xyZxyfooxyxyZ","xyZ")` exibe `"foo"`. |
| `strlen(str: string)` | número | Retorna o tamanho da string em pontos de código Unicode. |
| `toupper(str: string)` | string | Converte a string em letras maiúsculas. |
| `tolower(str: string)` | string | Converte a string em letras minúsculas. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | string | Retorna uma substring do índice especificado pelo argumento de número ao final da string. Se tiver um segundo argumento de número, a função conterá o tamanho da substring a ser recuperada. Por exemplo, `substr("xyZfooxyZ",3, 3)` exibe `"foo"`. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | string | Substitui todas as instâncias de `searchValue` em `fieldName: string` por `replaceValue`. Por exemplo, a função `replace(logGroup,"smoke_test","Smoke")` pesquisa eventos de log em que o campo `logGroup` contém o valor da string `smoke_test` e substitui o valor pela string `Smoke`. |
| `strcontains(str: string, searchValue: string)` | número | Retornará 1 se `str` contiver `searchValue` e 0, do contrário. |
# Campos contendo caracteres especiais
Se um campo contiver caracteres não alfanuméricos, exceto o símbolo `@` ou o ponto (`.`), você deverá delimitá-lo com caracteres de crase (```). Por exemplo, o campo de log `foo-bar` deve estar entre acentos graves (``foo-bar``) porque contém um caractere não alfanumérico, o hífen (`-`).
# Usar aliases e comentários em consultas
Crie consultas que contenham aliases. Use aliases para renomear campos de log ou ao extrair valores em campos. Use a palavra-chave `as` para dar um campo de log ou resultar em um alias. Você pode usar mais de um alias em uma consulta. Você pode usar aliases nos comandos a seguir:
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
Os exemplos a seguir mostram como criar consultas que contenham aliases.
**Exemplo**
A consulta contém um alias no comando `fields`.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
A consulta retorna os valores dos campos `@timestamp`, `@message` e `accountId`. Os resultados são classificados em ordem decrescente e limitados a 20. Os valores para `accountId` estão listados sob o alias `ID`.
**Exemplo**
A consulta contém um alias nos comandos `sort` e `stats`.
```
stats count(*) by duration as time
| sort time desc
```
A consulta conta o número de vezes que o campo `duration` ocorre no grupo de logs e classifica os resultados em ordem decrescente. Os valores para `duration` estão listados sob o alias `time`.
## Usar comentários
CloudWatch O Logs Insights oferece suporte a comentários em consultas. Use o caractere jogo da velha (**\$1**) para separar comentários. Você pode usar comentários para ignorar linhas em consultas ou consultas de documentos.
**Exemplo: consulta**
Quando a consulta a seguir é executada, a segunda linha é ignorada.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```
# Comece a usar o Logs Insights QL: tutoriais de consulta
As seções a seguir incluem exemplos de tutoriais de consulta para ajudar você a começar a usar o Logs Insights QL.
**Topics**
+ [Tutorial: executar e modificar um exemplo de consulta](CWL_AnalyzeLogData_RunSampleQuery.md)
+ [Tutorial: Executar uma consulta com uma função de agregação](CWL_AnalyzeLogData_AggregationQuery.md)
+ [Tutorial: Executar uma consulta que produz uma visualização agrupada por campos de log](CWL_AnalyzeLogData_VisualizationFieldQuery.md)
+ [Tutorial: Executar uma consulta que produz uma visualização de séries temporais](CWL_AnalyzeLogData_VisualizationQuery.md)
# Tutorial: executar e modificar um exemplo de consulta
O tutorial a seguir ajuda você a começar a usar o CloudWatch Logs Insights. Você executa uma consulta de amostra no Logs Insights QL e vê como modificá-la e voltar a executá-la.
Para executar uma consulta, você já deve ter registros armazenados em CloudWatch Registros. Se você já usa o CloudWatch Logs e tem grupos e fluxos de registros configurados, você está pronto para começar. Você também pode já ter registros se usar serviços como AWS CloudTrail Amazon Route 53 ou Amazon VPC e tiver configurado os registros desses serviços para CloudWatch acessar Logs. Para obter mais informações sobre o envio de registros para o CloudWatch Logs, consulte[Introdução ao CloudWatch Logs](CWL_GettingStarted.md).
As consultas no CloudWatch Logs Insights retornam um conjunto de campos de eventos de log ou o resultado de uma agregação matemática ou outra operação realizada em eventos de log. Este tutorial demonstra uma consulta que retorna uma lista de eventos de log.
## Executar um exemplo de consulta
**Para executar uma consulta de amostra do CloudWatch Logs Insights**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação à esquerda, escolha **Logs** e, em seguida, escolha **Log Insights**(Insights de log).
Na página **Logs Insights** (Insights de log), o editor de consultas contém uma consulta padrão no Logs Insights QL que retorna os 20 eventos de logs mais recentes.
1. No menu suspenso **Select log group(s)** (Selecione grupo(s) de logs), escolha um ou mais grupos de logs a serem consultados.
Se for uma conta de monitoramento na observabilidade CloudWatch entre contas, você poderá selecionar grupos de registros nas contas de origem e na conta de monitoramento. Uma única consulta pode consultar logs de diferentes contas ao mesmo tempo.
Você pode filtrar os grupos de log por nome de grupo de log, ID de conta ou rótulo de conta.
Quando você seleciona um grupo de registros na classe de registros padrão, o CloudWatch Logs Insights detecta automaticamente os campos de dados no grupo. Para ver esses campos descobertos, selecione o menu **Fields** (Campos) próximo ao canto superior direito da página.
**nota**
A descoberta de campos só é compatível com os grupos de logs da classe de logs Padrão. Para obter mais informações sobre classes de logs, consulte [Classes de logs](CloudWatch_Logs_Log_Classes.md).
1. (Opcional) Use o seletor de tempo para selecionar o período que você deseja consultar.
Você pode escolher intervalos de 5 a 30 minutos, intervalos de 1, 3 e 12 horas ou um período personalizado.
1. Selecione **Run** (Executar) para visualizar os resultados.
Para este tutorial, os resultados incluem os 20 eventos de log adicionados mais recentemente.
CloudWatch Os registros exibem um gráfico de barras dos eventos de registro no grupo de registros ao longo do tempo. O gráfico de barras mostra não apenas os eventos na tabela. mas também a distribuição de eventos no grupo de logs correspondente à consulta e ao intervalo de tempo.
1. Para ver todos os campos de um evento de log retornado, escolha o ícone suspenso triangular à esquerda do evento numerado.
## Modificar o exemplo de consulta
Neste tutorial, você modifica a consulta de amostra para mostrar os 50 eventos de log mais recentes.
Se você ainda não tiver executado o tutorial anterior, faça isso agora. Este tutorial começa onde esse tutorial anterior termina.
**nota**
Alguns exemplos de consultas fornecidos com o CloudWatch Logs Insights usam `tail` comandos `head` ou em vez de`limit`. Esses comandos estão defasados e foram substituídos por `limit`. Use `limit` em vez de `head` ou `tail` em todas as consultas que você gravar.
**Para modificar a consulta de amostra do CloudWatch Logs Insights**
1. No editor de consultas, altere **20** para **50**, e escolha **Executar**.
Os resultados da nova consulta são exibidos. Pressupondo-se que haja dados suficientes no grupo de logs no intervalo de tempo padrão, agora há 50 eventos de log listados.
1. (Opcional) Você pode salvar consultas que você criou. Para salvar essa consulta, escolha **Salvar**. Para obter mais informações, consulte [Salve e execute novamente as consultas do CloudWatch Logs Insights](CWL_Insights-Saving-Queries.md).
## Adicionar um comando de filtro ao exemplo de consulta
Este tutorial mostra como fazer uma alteração mais eficiente na consulta no editor. Neste tutorial, filtre os resultados da consulta anterior com base em um campo nos eventos de log recuperados.
Se você ainda não tiver executado os tutoriais anteriores, faça isso agora. Este tutorial começa onde esse tutorial anterior termina.
**Para adicionar um comando de filtro à consulta anterior**
1. Decida um campo a ser filtrado. Para ver os campos mais comuns que o CloudWatch Logs detectou nos eventos de log contidos nos grupos de log selecionados nos últimos 15 minutos e a porcentagem desses eventos de log nos quais cada campo aparece, selecione **Campos** no lado direito da página.
Para ver os campos contidos em um determinado evento de log, escolha o ícone à esquerda dessa linha.
O campo **awsRegion** pode ser exibido no evento de log, dependendo de quais eventos estão nos logs. No restante deste tutorial, usamos **awsRegion** como o campo de filtro, mas você pode usar um campo diferente caso esse campo não esteja disponível.
1. Na caixa do editor de consultas, coloque o cursor após **50** e pressione Enter.
1. Na nova linha, digite primeiro \$1 (o caractere de barra vertical) e um espaço. Os comandos em uma consulta do CloudWatch Logs Insights devem ser separados pelo caractere de barra vertical.
1. Insira **filter awsRegion="us-east-1"**.
1. Escolha **Executar**.
A consulta é reexecutada e agora exibe os 50 resultados mais recentes correspondentes ao novo filtro.
Se tiver filtrado em um campo diferente e obtido um resultado de erro, você poderá precisar inserir caracteres de escape no nome do campo. Se o nome do campo incluir caracteres não alfanuméricos, você deverá inserir caracteres de apóstrofo (`) antes e depois do nome do campo (por exemplo, **`error-code`="102"**).
Você deve usar os caracteres de apóstrofo para nomes de campo que contenham caracteres não alfanuméricos, mas não para valores. Os valores estão sempre entre aspas (").
O Logs Insights QL contém recursos de consulta eficientes, inclusive vários comandos e suporte para expressões regulares, além de operações matemáticas e estatísticas. Para obter mais informações, consulte [CloudWatch Sintaxe de consulta de linguagem do Logs Insights](CWL_QuerySyntax.md).
# Tutorial: Executar uma consulta com uma função de agregação
Você pode usar funções de agregação no comando `stats` e como argumentos de outras funções. Neste tutorial, você executará um comando de consulta que conta o número de eventos de log contendo um campo especificado. O comando de consulta retorna uma contagem total agrupada pelo valor ou valores do campo especificado. Para obter mais informações sobre funções de agregação, consulte [Operações e funções suportadas](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html#CWL_QuerySyntax-operations-functions) no *Guia do usuário do Amazon CloudWatch Logs*.
**Executar uma consulta com uma função de agregação**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação à esquerda, escolha **Logs** e, em seguida, escolha **Log Insights**(Insights de log).
1. Confirme se a guia **Logs Insights QL** está selecionada.
1. No menu suspenso **Select log group(s)** (Selecione grupo(s) de logs), escolha um ou mais grupos de logs a serem consultados.
Se for uma conta de monitoramento na observabilidade CloudWatch entre contas, você poderá selecionar grupos de registros nas contas de origem e na conta de monitoramento. Uma única consulta pode consultar logs de diferentes contas ao mesmo tempo.
Você pode filtrar os grupos de log por nome de grupo de log, ID de conta ou rótulo de conta.
Quando você seleciona um grupo de CloudWatch registros, o Logs Insights detecta automaticamente os campos de dados no grupo de registros se for um grupo de registros de classe padrão. Para ver esses campos descobertos, selecione o menu **Fields** (Campos) próximo ao canto superior direito da página.
1. Exclua a consulta padrão no editor de consultas e insira o seguinte comando:
```
stats count(*) by fieldName
```
1. *fieldName*Substitua por um campo descoberto no menu **Campos**.
O menu **Campos** está localizado no canto superior direito da página e exibe todos os campos descobertos que o CloudWatch Logs Insights detecta em seu grupo de registros.
1. Selecione **Run** (Executar) para visualizar os resultados da consulta.
Os resultados da consulta mostram o número de registros no grupo de logs que correspondem ao comando de consulta e a contagem total agrupada pelo valor ou valores do campo especificado.
# Tutorial: Executar uma consulta que produz uma visualização agrupada por campos de log
Ao executar uma consulta que usa a função `stats` para agrupar os resultados retornados pelos valores de um ou mais campos nas entradas de log, é possível visualizar os resultados como gráfico de barras, gráfico de pizza, grafo de linhas ou grafo de área empilhada. Isso ajuda a visualizar as tendências em seus logs de forma mais eficiente.
**Para executar uma consulta de visualização**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação à esquerda, escolha **Logs** e, em seguida, escolha **Log Insights**(Insights de log).
1. No menu suspenso **Select log group(s)** (Selecione grupo(s) de logs), escolha um ou mais grupos de logs a serem consultados.
Se for uma conta de monitoramento na observabilidade CloudWatch entre contas, você poderá selecionar grupos de registros nas contas de origem e na conta de monitoramento. Uma única consulta pode consultar logs de diferentes contas ao mesmo tempo.
Você pode filtrar os grupos de log por nome de grupo de log, ID de conta ou rótulo de conta.
1. No editor de consultas, exclua o conteúdo atual, insira a função `stats` a seguir e escolha **Run query**(Executar consulta).
```
stats count(*) by @logStream
| limit 100
```
Os resultados mostram o número de eventos de log no grupo de logs para cada fluxo de log. Os resultados são limitados a somente 100 linhas.
1. Escolha a guia **Visualization** (Visualização).
1. Selecione a seta ao lado de **Linha**, e escolha **Barra**.
O gráfico de barras será exibido, mostrando uma barra para cada fluxo de log no grupo de logs.
# Tutorial: Executar uma consulta que produz uma visualização de séries temporais
Ao executar uma consulta que usa a função `bin()` para agrupar os resultados retornados por um período, é possível visualizar os resultados como um grafo de linhas, um grafo de áreas empilhadas, um gráfico de pizza ou gráfico de barras. Isso ajuda a visualizar as tendências em eventos de log ao longo do tempo de modo mais eficiente.
**Para executar uma consulta de visualização**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação à esquerda, escolha **Logs** e, em seguida, escolha **Log Insights**(Insights de log).
1. Confirme se a guia **Logs Insights QL** está selecionada.
1. No menu suspenso **Select log group(s)** (Selecione grupo(s) de logs), escolha um ou mais grupos de logs a serem consultados.
Se for uma conta de monitoramento na observabilidade CloudWatch entre contas, você poderá selecionar grupos de registros nas contas de origem e na conta de monitoramento. Uma única consulta pode consultar logs de diferentes contas ao mesmo tempo.
Você pode filtrar os grupos de log por nome de grupo de log, ID de conta ou rótulo de conta.
1. No editor de consultas, exclua o conteúdo atual, insira a função `stats` a seguir e escolha **Run query**(Executar consulta).
```
stats count(*) by bin(30s)
```
Os resultados mostram o número de eventos de registro no grupo de registros que foram recebidos pelo CloudWatch Logs em cada período de 30 segundos.
1. Escolha a guia **Visualization** (Visualização).
Os resultados são mostrados como um gráfico de linhas. Para alternar para um gráfico de barras, de pizza ou de áreas empilhadas, escolha a seta ao lado de **Line** (Linha) no canto superior direito do grafo.
# Exemplos de consultas
Esta seção contém uma lista de comandos de consulta gerais e úteis que você pode executar no [CloudWatchconsole](https://console.aws.amazon.com/cloudwatch/). Para obter informações sobre como executar um comando de consulta, consulte [Tutorial: Executar e modificar uma consulta de amostra](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) no *Guia do usuário do Amazon CloudWatch Logs*.
Para obter mais informações sobre a sintaxe das consultas, consulte [CloudWatch Sintaxe de consulta de linguagem do Logs Insights](CWL_QuerySyntax.md).
**Topics**
+ [Consultas gerais](#CWL_QuerySyntax-examples-general)
+ [Consultas de logs do Lambda](#CWL_QuerySyntax-examples-Lambda)
+ [Consultas para logs de fluxo da Amazon VPC](#CWL_QuerySyntax-examples-VPC)
+ [Consultas de logs do Route 53](#CWL_QuerySyntax-examples-Route53)
+ [Consultas para registros CloudTrail](#CWL_QuerySyntax-examples-CloudTrail)
+ [Consultas para Amazon API Gateway](#CWL_QuerySyntax-examples-APIGateway)
+ [Consultas para gateway NAT](#CWL_QuerySyntax-examples-NATGateway)
+ [Consultas para logs do servidor Apache](#CWL_QuerySyntax-examples-Apache)
+ [Consultas para a Amazon EventBridge](#CWL_QuerySyntax-examples-EventBridge)
+ [Exemplos do comando de análise](#CWL_QuerySyntax-examples-parse)
## Consultas gerais
**Encontre os 25 eventos de log adicionados mais recentemente.**
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
**Obtenha uma lista do número de exceções por hora.**
```
filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
```
**Obtenha uma lista de eventos de log que não sejam exceções.**
```
fields @message | filter @message not like /Exception/
```
**Obtenha o evento de log mais recente para cada valor exclusivo do campo `server`.**
```
fields @timestamp, server, severity, message
| sort @timestamp asc
| dedup server
```
**Obtenha o evento de log mais recente para cada valor exclusivo do campo `server` para cada tipo `severity`.**
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server, severity
```
## Consultas de logs do Lambda
**Determine a quantidade de memória provisionada excessivamente.**
```
filter @type = "REPORT"
| stats max(@memorySize / 1000 / 1000) as provisonedMemoryMB,
min(@maxMemoryUsed / 1000 / 1000) as smallestMemoryRequestMB,
avg(@maxMemoryUsed / 1000 / 1000) as avgMemoryUsedMB,
max(@maxMemoryUsed / 1000 / 1000) as maxMemoryUsedMB,
provisonedMemoryMB - maxMemoryUsedMB as overProvisionedMB
```
**Crie um relatório de latência.**
```
filter @type = "REPORT" |
stats avg(@duration), max(@duration), min(@duration) by bin(5m)
```
**Procure invocações de funções lentas e elimine solicitações duplicadas que podem surgir de novas tentativas ou código no lado do cliente. Nessa consulta, `@duration` está em milissegundos.**
```
fields @timestamp, @requestId, @message, @logStream
| filter @type = "REPORT" and @duration > 1000
| sort @timestamp desc
| dedup @requestId
| limit 20
```
## Consultas para logs de fluxo da Amazon VPC
**Encontre as 15 principais transferências de pacotes nos hosts:**
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
**Encontre as 15 principais transferências de bytes para hosts em uma determinada sub-rede.**
```
filter isIpv4InSubnet(srcAddr, "192.0.2.0/24")
| stats sum(bytes) as bytesTransferred by dstAddr
| sort bytesTransferred desc
| limit 15
```
**Encontre os endereços IP que usam o UDP como um protocolo de transferência de dados.**
```
filter protocol=17 | stats count(*) by srcAddr
```
**Encontre os endereços IP nos quais os registros do fluxo foram ignorados durante a janela de captura.**
```
filter logStatus="SKIPDATA"
| stats count(*) by bin(1h) as t
| sort t
```
**Encontre um único registro para cada conexão para ajudar a solucionar problemas de conectividade com a rede.**
```
fields @timestamp, srcAddr, dstAddr, srcPort, dstPort, protocol, bytes
| filter logStream = 'vpc-flow-logs' and interfaceId = 'eni-0123456789abcdef0'
| sort @timestamp desc
| dedup srcAddr, dstAddr, srcPort, dstPort, protocol
| limit 20
```
## Consultas de logs do Route 53
**Encontre a distribuição de registros por hora por tipo de consulta.**
```
stats count(*) by queryType, bin(1h)
```
**Encontre os 10 resolvedores DNS com o maior número de solicitações.**
```
stats count(*) as numRequests by resolverIp
| sort numRequests desc
| limit 10
```
**Encontre o número de registros por domínio e subdomínio em que o servidor deixou de concluir a solicitação DNS.**
```
filter responseCode="SERVFAIL" | stats count(*) by queryName
```
## Consultas para registros CloudTrail
**Encontre o número de entradas de registro para cada serviço, tipo de evento e AWS região.**
```
stats count(*) by eventSource, eventName, awsRegion
```
**Encontre os hosts do Amazon EC2 que foram iniciados ou parados em uma determinada AWS região.**
```
filter (eventName="StartInstances" or eventName="StopInstances") and awsRegion="us-east-2"
```
**Encontre as AWS regiões, os nomes ARNs de usuário e os usuários recém-criados do IAM.**
```
filter eventName="CreateUser"
| fields awsRegion, requestParameters.userName, responseElements.user.arn
```
**Encontre o número de registros em que ocorreu uma exceção durante a invocação da API `UpdateTrail`.**
```
filter eventName="UpdateTrail" and ispresent(errorCode)
| stats count(*) by errorCode, errorMessage
```
**Encontre entradas de log em que TLS 1.0 ou 1.1 foi usado**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by userIdentity.accountId, recipientAccountId, eventSource, eventName, awsRegion, tlsDetails.tlsVersion, tlsDetails.cipherSuite, userAgent
| sort eventSource, eventName, awsRegion, tlsDetails.tlsVersion
```
**Encontre o número de chamadas por serviço que usaram o TLS versões 1.0 ou 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by eventSource
| sort numOutdatedTlsCalls desc
```
## Consultas para Amazon API Gateway
Encontre os 10 últimos erros 4XX
```
fields @timestamp, status, ip, path, httpMethod
| filter status>=400 and status<=499
| sort @timestamp desc
| limit 10
```
Identifique as 10 Amazon API Gateway solicitações mais antigas em seu grupo de registros de Amazon API Gateway acesso
```
fields @timestamp, status, ip, path, httpMethod, responseLatency
| sort responseLatency desc
| limit 10
```
Retorne a lista dos caminhos de API mais populares no seu grupo de logs de acesso do Amazon API Gateway
```
stats count(*) as requestCount by path
| sort requestCount desc
| limit 10
```
Crie um relatório de latência de integração para seu grupo de logs de acesso do Amazon API Gateway
```
filter status=200
| stats avg(integrationLatency), max(integrationLatency),
min(integrationLatency) by bin(1m)
```
## Consultas para gateway NAT
Se você notar custos mais altos do que o normal em sua AWS fatura, você pode usar o CloudWatch Logs Insights para encontrar os principais contribuidores. Para obter mais informações sobre os seguintes comandos de consulta, consulte [Como posso encontrar os principais contribuidores para o tráfego por meio do gateway NAT na minha VPC](https://aws.amazon.com/premiumsupport/knowledge-center/vpc-find-traffic-sources-nat-gateway/)? na página de suporte AWS premium.
**nota**
Nos comandos de consulta a seguir, substitua “x.x.x.x” pelo IP privado do gateway NAT e substitua “y.y” pelos dois primeiros octetos do intervalo CIDR da VPC.
**Encontre as instâncias que estão enviando mais tráfego por meio de seu gateway NAT.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Determine o tráfego de/para as instâncias em seus gateways NAT.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.') or (srcAddr like 'xxx.xx.xx.xx' and dstAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Determine os destinos da Internet com os quais as instâncias em sua VPC se comunicam com mais frequência para uploads e downloads.**
*****Para uploads*****
```
filter (srcAddr like 'x.x.x.x' and dstAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
*****Para downloads*****
```
filter (dstAddr like 'x.x.x.x' and srcAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
## Consultas para logs do servidor Apache
Você pode usar o CloudWatch Logs Insights para consultar os registros do servidor Apache. Para obter mais informações sobre as consultas a seguir, consulte [Simplificando os registros do servidor Apache com CloudWatch o Logs Insights no blog](https://aws.amazon.com/blogs/mt/simplifying-apache-server-logs-with-amazon-cloudwatch-logs-insights/) AWS Cloud Operations & Migrations.
**Encontre os campos mais relevantes para que você possa revisar seus logs de acesso e verificar se há tráfego no caminho */admin* da aplicação.**
```
fields @timestamp, remoteIP, request, status, filename| sort @timestamp desc
| filter filename="/var/www/html/admin"
| limit 20
```
**Encontre o número de solicitações GET exclusivas que acessaram sua página principal com o código de status “200” (sucesso).**
```
fields @timestamp, remoteIP, method, status
| filter status="200" and referrer= http://34.250.27.141/ and method= "GET"
| stats count_distinct(remoteIP) as UniqueVisits
| limit 10
```
**Encontre o número de vezes que o serviço Apache foi reiniciado.**
```
fields @timestamp, function, process, message
| filter message like "resuming normal operations"
| sort @timestamp desc
| limit 20
```
## Consultas para a Amazon EventBridge
Obtenha o número de EventBridge eventos agrupados por tipo de detalhe do evento
```
fields @timestamp, @message
| stats count(*) as numberOfEvents by `detail-type`
| sort numberOfEvents desc
```
## Exemplos do comando de análise
**Use uma expressão de glob para extrair os campos `@user`, `@method` e `@latency` do campo de log `@message` e retornar a latência média para cada combinação exclusiva de `@method` e `@user`.**
```
parse @message "user=*, method:*, latency := *" as @user,
@method, @latency | stats avg(@latency) by @method,
@user
```
**Use uma expressão regular para extrair os campos `@user2`, `@method2` e `@latency2` do campo de log `@message` e retornar a latência média para cada combinação exclusiva de `@method2` e `@user2`.**
```
parse @message /user=(?.*?), method:(?.*?),
latency := (?.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrai os campos `loggingTime`, `loggingType` e `loggingMessage`, aplica o filtro para eventos de logs que contêm strings `ERROR` ou `INFO` e exibe apenas os campos `loggingMessage` e `loggingType` para eventos que contêm uma string `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# Compare (diff) com intervalos de tempo anteriores
Você pode usar o CloudWatch Logs Insights com o QL do Logs Insights para comparar as alterações em seus eventos de registro ao longo do tempo. Você pode comparar os eventos de log ingeridos durante um intervalo de tempo recente com os logs do período imediatamente anterior. Ou então, pode comparar com períodos passados similares. Isso pode ajudar a descobrir se um erro nos logs foi introduzido recentemente ou se já estava ocorrendo, além de ajudar a encontrar outras tendências.
As consultas de comparação retornam apenas padrões nos resultados, não eventos de log brutos. Os padrões retornados ajudarão você a ver rapidamente tendências e mudanças nos eventos de log ao longo do tempo. Depois que você executa uma consulta de comparação e obtém resultados de padrões, pode ver exemplos de eventos de log brutos para os padrões em que estiver interessado. Para obter mais informações sobre padrões de log, consulte [Análise de padrões](CWL_AnalyzeLogData_Patterns.md).
Quando você executa uma consulta de comparação, ela é analisada em relação a dois períodos diferentes: o período original de consulta que você seleciona e o período de comparação. O período de comparação é sempre igual ao período de consulta original. Os intervalos de tempo padrão para as comparações são que se seguem.
+ **Período anterior**: compara com o período imediatamente anterior ao período da sua consulta.
+ **Dia anterior**: compara com o período um dia antes do período da sua consulta.
+ **Semana anterior**: compara com o período uma semana antes do período da sua consulta.
+ **Mês anterior**: compara com o período um mês antes do período da sua consulta.
**nota**
As consultas que usam comparações geram cobranças semelhantes às da execução de uma única consulta do CloudWatch Logs Insights no intervalo de tempo combinado. Para obter mais informações, consulte [Definição de preço do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**Para executar uma consulta de comparação**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. No painel de navegação, escolha **Logs**, **Logs Insights**.
Uma consulta padrão aparece na caixa de consulta.
1. Confirme se a guia **Logs Insights QL** está selecionada.
1. Mantenha a consulta padrão ou insira outra consulta.
1. No menu suspenso **Selecionar grupos de logs**, escolha um ou mais grupos de logs para consultar.
1. (Opcional) Use o seletor de tempo para selecionar o período que você deseja consultar. A consulta padrão é para a hora anterior de dados de log.
1. No seletor de intervalos de tempo, escolha **Comparar**. Depois, escolha o período anterior com o qual você deseja comparar os logs originais e escolha **Aplicar**.
1. Selecione **Executar consulta**.
Para que a consulta busque os dados no período de comparação, o comando `diff` é adicionado ao fim da consulta ela.
1. Escolha a guia **Padrões** para ver os resultados.
A tabela exibe as seguintes informações:
+ Cada **padrão**, com as partes variáveis do padrão substituídas pelo símbolo de token dinâmico ``. *string*É uma descrição do tipo de dados que o token representa. *number*Mostra onde esse token aparece no padrão, em comparação com os outros tokens dinâmicos. Para obter mais informações, consulte [Análise de padrões](CWL_AnalyzeLogData_Patterns.md).
+ **Número de eventos** é o número de eventos de log com esse padrão no período original mais atual.
+ **Diferença de número de eventos** é a diferença entre o número de eventos de log correspondentes no período atual em relação ao período de comparação. Uma diferença positiva significa que há mais eventos desse tipo no período atual.
+ **Descrição da diferença** resume brevemente a alteração no padrão entre o período atual e o período de comparação.
+ **Tipo de gravidade** é a provável gravidade dos eventos de log com esse padrão, baseado nas palavras encontradas nos eventos de log, como `FATAL`, `ERROR`, e `WARN`.
1. Para inspecionar melhor um dos padrões na lista, escolha o ícone na coluna **Inspecionar** para um dos padrões.
O painel **Inspeção de padrões** aparece e exibe o seguinte:
+ O **padrão**. Selecione um token no padrão para analisar os valores desse token.
+ Um histograma mostrando o número de ocorrências do padrão no intervalo consultado. Isso pode ajudar a identificar tendências interessantes, como um aumento repentino na ocorrência de um padrão.
+ A guia **Exemplos de log** exibe alguns eventos de log que correspondem ao padrão selecionado.
+ A guia **Valores do token** exibe os valores do token dinâmico selecionado, se você tiver selecionado um.
**nota**
No máximo de 10 valores de token são capturados para cada token. A contagem de tokens pode não ser precisa. CloudWatch O Logs usa um contador probabilístico para gerar a contagem de tokens, não o valor absoluto.
+ A guia **Padrões relacionados** exibe outros padrões que ocorreram com frequência quase ao mesmo tempo que o padrão que você está inspecionando. Por exemplo, se um padrão para uma mensagem `ERROR` geralmente foi acompanhado por outro evento de log marcado como `INFO` com detalhes adicionais, esse padrão será exibido aqui.
# Visualize dados de log em grafos
Você pode usar visualizações como gráficos de barras, gráficos de linhas e gráficos de áreas empilhadas para identificar com mais eficiência padrões em seus dados de registro. CloudWatch O Logs Insights gera visualizações para consultas que usam a `stats` função e uma ou mais funções de agregação. Para obter mais informações, consulte [stats](CWL_QuerySyntax-Stats.md).