.*?)/ | 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
```