As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Processadores configuráveis do tipo analisador
Esta seção contém informações sobre os processadores de analisadores de dados configuráveis que você pode usar em um transformador de eventos de log.
**Contents**
+ [parseJSON](#CloudWatch-Logs-Transformation-parseJSON)
+ [grok](#CloudWatch-Logs-Transformation-Grok)
+ [Exemplos do Grok](#Grok-Examples)
+ [Exemplo 1: use o Grok para extrair um campo de logs não estruturados](#Grok-Example1)
+ [Exemplo 2: use o Grok em combinação com parseJSON para extrair campos de um evento de logs JSON](#Grok-Example3)
+ [Exemplo 3: padrão Grok com anotação pontilhada em FIELD\$1NAME](#Grok-Example4)
+ [Padrões Grok compatíveis](#Grok-Patterns)
+ [Exemplos comuns de formato de log](#Common-Log-Examples)
+ [Exemplo de log do Apache](#Apache-Log-Example)
+ [Exemplo de log do NGINX](#NGINX-Log-Example)
+ [Exemplo de log do protocolo Syslog (RFC 5424)](#syslog5424-Log-Example)
+ [csv](#CloudWatch-Logs-Transformation-csv)
+ [parseKeyValue](#CloudWatch-Logs-Transformation-parseKeyValue)
## parseJSON
O processador **parseJSON** analisa os eventos de logs JSON e insere os pares de valores-chave JSON extraídos no destino. Se você não especificar um destino, o processador colocará o par de valores-chave sob o nó raiz. Ao usar o `parseJSON` como primeiro processador, você deve analisar todo o evento de logs usando `@message` como campo de origem. Após a análise inicial do JSON, você pode manipular campos específicos nos processadores subsequentes.
O conteúdo `@message` original não é alterado, as novas chaves são adicionadas à mensagem.
| Campo | Description | Obrigatório? | Padrão | Limites |
| --- | --- | --- | --- | --- |
| origem | Caminho para o campo no evento de logs que será analisado. Use a notação de pontos para acessar os campos secundários. Por exemplo, store.book. | Não | `@message` | Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
| destination | O campo de destino do JSON analisado | Não | `Parent JSON node` | Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
**Exemplo**
Suponha que um evento de logs ingerido seja semelhante a:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
Então, se tivermos esse processador **parseJSON**:
```
[
{
"parseJSON": {
"destination": "new_key"
}
}
]
```
O evento de logs transformado seria o seguinte.
```
{
"new_key": {
"outer_key": {
"inner_key": "inner_value"
}
}
}
```
## grok
Use o processador Grok para analisar e estruturar dados não estruturados usando correspondência de padrões. Esse processador também pode extrair campos de mensagens de log.
| Campo | Description | Obrigatório? | Padrão | Limites | Observações |
| --- | --- | --- | --- | --- | --- |
| origem | Caminho do campo no qual aplicar a correspondência Grok | Não | `@message` | Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
| match | O padrão Grok para combinar com o evento de logs | Sim | | Tamanho máximo: 512 Máximo de padrões Grok: 20 Alguns tipos de padrões Grok têm limites de uso individuais. Qualquer combinação dos seguintes padrões pode ser usada até cinco vezes: \$1URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA\$1MULTILINE\$1 Os padrões Grok não oferecem suporte a conversões de tipos. Para padrões de formato de log comuns (APACHE\$1ACCESS\$1LOG, NGINX\$1ACCESS\$1LOG, SYSLOG5424), somente os padrões DATA, GREEDYDATA ou GREEDYDATA\$1MULTILINE podem ser incluídos após o padrão de log comum. | [Veja todos os padrões Grok compatíveis](#Grok-Patterns) |
**Estrutura de um padrão Grok**
Esta é a estrutura do padrão Grok compatível:
```
%{PATTERN_NAME:FIELD_NAME}
```
+ **PATTERN\$1NAME**: refere-se a uma expressão regular predefinida para corresponder a um tipo específico de dados. Somente [padrões grok predefinidos são suportados](#Grok-Patterns). Não é permitido criar padrões personalizados.
+ **FIELD\$1NAME**: atribui um nome ao valor extraído. `FIELD_NAME` é opcional, mas se você não especificar esse valor, os dados extraídos serão eliminados do evento de logs transformado. Se `FIELD_NAME` usa notação pontilhada (por exemplo, “parent.child”), ele é considerado um caminho JSON.
+ **Conversão de tipo**: conversões de tipo explícitas não são suportadas. Use o [TypeConverter processador](CloudWatch-Logs-Transformation-Datatype.md#CloudWatch-Logs-Transformation-typeConverter) para converter o tipo de dados de qualquer valor extraído pelo grok.
Para criar expressões de correspondência mais complexas, você pode combinar vários padrões Grok. Até 20 padrões Grok podem ser combinados para corresponder a um evento de logs. Por exemplo, essa combinação de padrões `%{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data}` pode ser usada para extrair campos de uma entrada de log lenta do Redis, como esta:
`1629860738.123456 [0 127.0.0.1:6379] "SET" "key1" "value1"`
### Exemplos do Grok
#### Exemplo 1: use o Grok para extrair um campo de logs não estruturados
Log de amostra:
```
293750 server-01.internal-network.local OK "[Thread-000] token generated"
```
Transformador usado:
```
[
{
"grok": {
"match": "%{NUMBER:version} %{HOSTNAME:hostname} %{NOTSPACE:status} %{QUOTEDSTRING:logMsg}"
}
}
]
```
Saída:
```
{
"version": "293750",
"hostname": "server-01.internal-network.local",
"status": "OK",
"logMsg": "[Thread-000] token generated"
}
```
Log de amostra:
```
23/Nov/2024:10:25:15 -0900 172.16.0.1 200
```
Transformador usado:
```
[
{
"grok": {
"match": "%{HTTPDATE:timestamp} %{IPORHOST:clientip} %{NUMBER:response_status}"
}
}
]
```
Saída:
```
{
"timestamp": "23/Nov/2024:10:25:15 -0900",
"clientip": "172.16.0.1",
"response_status": "200"
}
```
#### Exemplo 2: use o Grok em combinação com parseJSON para extrair campos de um evento de logs JSON
Log de amostra:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"level": "ERROR",
"logMsg": "GET /page.html HTTP/1.1"
}
```
Transformador usado:
```
[
{
"parseJSON": {}
},
{
"grok": {
"source": "logMsg",
"match": "%{WORD:http_method} %{NOTSPACE:request} HTTP/%{NUMBER:http_version}"
}
}
]
```
Saída:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"level": "ERROR",
"logMsg": "GET /page.html HTTP/1.1",
"http_method": "GET",
"request": "/page.html",
"http_version": "1.1"
}
```
#### Exemplo 3: padrão Grok com anotação pontilhada em FIELD\$1NAME
Log de amostra:
```
192.168.1.1 GET /index.html?param=value 200 1234
```
Transformador usado:
```
[
{
"grok": {
"match": "%{IP:client.ip} %{WORD:method} %{URIPATHPARAM:request.uri} %{NUMBER:response.status} %{NUMBER:response.bytes}"
}
}
]
```
Saída:
```
{
"client": {
"ip": "192.168.1.1"
},
"method": "GET",
"request": {
"uri": "/index.html?param=value"
},
"response": {
"status": "200",
"bytes": "1234"
}
}
```
### Padrões Grok compatíveis
As tabelas a seguir listam os padrões que são compatíveis com o processador `grok`.
**Padrões Grok gerais**
| Padrão Grok | Description | Limite máximo de padrões | Exemplo |
| --- | --- | --- | --- |
| USERNAME ou USER | Corresponde a um ou mais caracteres que podem incluir letras minúsculas (a-z), letras maiúsculas (A-Z), dígitos (0-9), pontos (.), sublinhados (\$1) ou hifens (-). | 20 | Entrada: `user123.name-TEST` Padrão: `%{USERNAME:name}` Saída: `{"name": "user123.name-TEST"}` |
| INT | Corresponde a um sinal opcional de mais ou menos seguido por um ou mais dígitos. | 20 | Entrada: `-456` Padrão: `%{INT:num}` Saída: `{"num": "-456"}` |
| BASE10NUM | Corresponde a um número inteiro ou de ponto flutuante com sinal e ponto decimal opcionais | 20 | Entrada: `-0.67` Padrão: `%{BASE10NUM:num}` Saída: `{"num": "-0.67"}` |
| BASE16NUM | Combina números decimais e hexadecimais com um sinal opcional (\$1 ou -) e um prefixo 0x opcional | 20 | Entrada: `+0xA1B2` Padrão: `%{BASE16NUM:num}` Saída: `{"num": "+0xA1B2"}` |
| POSINT | Corresponde a números inteiros positivos sem zeros à esquerda, consistindo em um ou mais dígitos (1-9 seguido por 0-9) | 20 | Entrada: `123` Padrão: `%{POSINT:num}` Saída: `{"num": "123"}` |
| NONNEGINT | Corresponde a qualquer número inteiro (consistindo em um ou mais dígitos de 0 a 9), incluindo zero e números com zeros à esquerda. | 20 | Entrada: `007` Padrão: `%{NONNEGINT:num}` Saída: `{"num": "007"}` |
| WORD | Corresponde a palavras inteiras compostas por um ou mais caracteres (\$1w), incluindo letras, dígitos e sublinhados | 20 | Entrada: `user_123` Padrão: `%{WORD:user}` Saída: `{"user": "user_123"}` |
| NOTSPACE | Corresponde a um ou mais caracteres que não sejam espaços em branco. | 5 | Entrada: `hello_world123` Padrão: `%{NOTSPACE:msg}` Saída: `{"msg": "hello_world123"}` |
| SPACE | Corresponde a zero ou mais caracteres de espaço em branco. | 5 | Entrada: `" "` Padrão: `%{SPACE:extra}` Saída: `{"extra": " "}` |
| DATA | Corresponde a qualquer caractere (exceto nova linha) zero ou mais vezes, de forma não gananciosa. | 5 | Entrada: `abc def ghi` Padrão: `%{DATA:x} %{DATA:y}` Saída: `{"x": "abc", "y": "def ghi"}` |
| GREEDYDATA | Corresponde a qualquer caractere (exceto nova linha) zero ou mais vezes, de forma gananciosa. | 5 | Entrada: `abc def ghi` Padrão: `%{GREEDYDATA:x} %{GREEDYDATA:y}` Saída: `{"x": "abc def", "y": "ghi"}` |
| GREEDYDATA\$1MULTILINE | Corresponde a qualquer caractere (incluindo nova linha) zero ou mais vezes, de forma gananciosa. | 1 | Entrada: `abc` `def` `ghi` Padrão: `%{GREEDYDATA_MULTILINE:data}` Saída: `{"data": "abc\ndef\nghi"}` |
| QUOTEDSTRING | Combina cadeias de caracteres entre aspas (aspas simples ou duplas) com caracteres de escape. | 20 | Entrada: `"Hello, world!"` Padrão: `%{QUOTEDSTRING:msg}` Saída: `{"msg": "Hello, world!"}` |
| UUID | Corresponde a um formato UUID padrão: 8 caracteres hexadecimais, seguidos por três grupos de 4 caracteres hexadecimais e terminando com 12 caracteres hexadecimais, todos separados por hifens. | 20 | Entrada: `550e8400-e29b-41d4-a716-446655440000` Padrão: `%{UUID:id}` Saída: `{"id": "550e8400-e29b-41d4-a716-446655440000"}` |
| URN | Corresponde à sintaxe URN (Uniform Resource Name). | 20 | Entrada: `urn:isbn:0451450523` Padrão: `%{URN:urn}` Saída: `{"urn": "urn:isbn:0451450523"}` |
**AWS padrões grok**
| Padrão | Description | Limite máximo de padrões | Exemplo |
| --- | --- | --- | --- |
| ARN | Corresponde aos nomes de recursos da AWS Amazon (ARNs), capturando a partição (`aws`,`aws-cn`, ou`aws-us-gov`), o serviço, a região, o ID da conta e até 5 identificadores hierárquicos de recursos separados por barras. Não corresponderá às informações ARNs que faltam entre dois pontos. | 5 | Entrada: `arn:aws:iam:us-east-1:123456789012:user/johndoe` Padrão: `%{ARN:arn}` Saída: `{"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}` |
**Padrões Grok de redes**
| Padrão Grok | Description | Limite máximo de padrões | Exemplo |
| --- | --- | --- | --- |
| CISCOMAC | Corresponde a um endereço MAC no formato hexadecimal 4-4-4. | 20 | Entrada: `0123.4567.89AB` Padrão: `%{CISCOMAC:MacAddress}` Saída: `{"MacAddress": "0123.4567.89AB"}` |
| WINDOWSMAC | Corresponde a um endereço MAC em formato hexadecimal com hifens | 20 | Entrada: `01-23-45-67-89-AB` Padrão: `%{WINDOWSMAC:MacAddress}` Saída: `{"MacAddress": "01-23-45-67-89-AB"}` |
| COMMONMAC | Corresponde a um endereço MAC em formato hexadecimal com dois pontos. | 20 | Entrada: `01:23:45:67:89:AB` Padrão: `%{COMMONMAC:MacAddress}` Saída: `{"MacAddress": "01:23:45:67:89:AB"}` |
| Mac | Corresponde a um dos padrões Grok CISCOMAC, WINDOWSMAC ou COMMONMAC | 20 | Entrada: `01:23:45:67:89:AB` Padrão: `%{MAC:m1}` Saída: `{"m1":"01:23:45:67:89:AB"}` |
| IPV6 | Corresponde a IPv6 endereços, incluindo formulários compactados e endereços IPv4 mapeados IPv6 . | 5 | Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Padrão: `%{IPV6:ip}` Saída: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| IPV4 | Corresponde a um IPv4 endereço. | 20 | Entrada: `192.168.0.1` Padrão: `%{IPV4:ip}` Saída: `{"ip": "192.168.0.1"}` |
| IP | Corresponde aos IPv6 endereços suportados por% \$1IPv6\$1 ou aos IPv4 endereços compatíveis com% \$1IPv4\$1 | 5 | Entrada: `192.168.0.1` Padrão: `%{IP:ip}` Saída: `{"ip": "192.168.0.1"}` |
| HOSTNAME ou HOST | Corresponde a nomes de domínio, incluindo subdomínios | 5 | Entrada: `server-01.internal-network.local` Padrão: `%{HOST:host}` Saída: `{"host": "server-01.internal-network.local"}` |
| IPORHOST | Corresponde a um nome de host ou endereço IP | 5 | Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Padrão: `%{IPORHOST:ip}` Saída: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| HOSTPORT | Corresponde a um endereço IP ou nome de host, conforme suportado pelo padrão %\$1IPORHOST\$1 seguido por dois pontos e um número de porta, capturando a porta como “PORT” na saída. | 5 | Entrada: `192.168.1.1:8080` Padrão: `%{HOSTPORT:ip}` Saída: `{"ip":"192.168.1.1:8080","PORT":"8080"}` |
| URIHOST | Corresponde a um endereço IP ou nome de host, conforme suportado pelo padrão %\$1IPORHOST\$1, opcionalmente seguido por dois pontos e um número de porta, capturando a porta como “port”, se presente. | 5 | Entrada: `example.com:443 10.0.0.1` Padrão: `%{URIHOST:host} %{URIHOST:ip}` Saída: `{"host":"example.com:443","port":"443","ip":"10.0.0.1"}` |
**Padrões Grok de caminho**
| Padrão Grok | Description | Limite máximo de padrões | Exemplo |
| --- | --- | --- | --- |
| UNIXPATH | Corresponde aos caminhos de URL, incluindo potencialmente parâmetros de consulta. | 20 | Entrada: `/search?q=regex` Padrão: `%{UNIXPATH:path}` Saída: `{"path":"/search?q=regex"}` |
| WINPATH | Corresponde aos caminhos dos arquivos do Windows. | 5 | Entrada: `C:\Users\John\Documents\file.txt` Padrão: `%{WINPATH:path}` Saída: `{"path": "C:\\Users\\John\\Documents\\file.txt"}` |
| PATH | Corresponde aos caminhos de arquivo do URL ou do Windows | 5 | Entrada: `/search?q=regex` Padrão: `%{PATH:path}` Saída: `{"path":"/search?q=regex"}` |
| TTY | Combina caminhos de dispositivos Unix para terminais e pseudoterminais. | 20 | Entrada: `/dev/tty1` Padrão: `%{TTY:path}` Saída: `{"path":"/dev/tty1"}` |
| URIPROTO | Corresponde a letras, opcionalmente seguidas por um caractere de adição (\$1) e letras adicionais ou caracteres de adição (\$1) | 20 | Entrada: `web+transformer` Padrão: `%{URIPROTO:protocol}` Saída: `{"protocol":"web+transformer"}` |
| URIPATH | Corresponde ao componente de caminho de um URI | 20 | Entrada: `/category/sub-category/product_name` Padrão: `%{URIPATH:path}` Saída: `{"path":"/category/sub-category/product_name"}` |
| URIPARAM | Corresponde aos parâmetros de consulta de URL | 5 | Entrada: `?param1=value1¶m2=value2` Padrão: `%{URIPARAM:url}` Saída: `{"url":"?param1=value1¶m2=value2"}` |
| URIPATHPARAM | Corresponde a um caminho de URI, opcionalmente seguido por parâmetros de consulta | 5 | Entrada: `/category/sub-category/product?id=12345&color=red` Padrão: `%{URIPATHPARAM:path}` Saída: `{"path":"/category/sub-category/product?id=12345&color=red"}` |
| URI | Corresponde a um URI completo | 5 | Entrada: `https://user:password@example.com/path/to/resource?param1=value1¶m2=value2` Padrão: `%{URI:uri}` Saída: `{"path":"https://user:password@example.com/path/to/resource?param1=value1¶m2=value2"}` |
**Padrões Grok de data e hora**
| Padrão Grok | Description | Limite máximo de padrões | Exemplo |
| --- | --- | --- | --- |
| MONTH | Combina nomes completos ou abreviados dos meses em inglês como palavras inteiras | 20 | Entrada: `Jan` Padrão: `%{MONTH:month}` Saída: `{"month":"Jan"}` Entrada: `January` Padrão: `%{MONTH:month}` Saída: `{"month":"January"}` |
| MONTHNUM | Corresponde aos números dos meses de 1 a 12, com zero inicial opcional para meses de um dígito. | 20 | Entrada: `5` Padrão: `%{MONTHNUM:month}` Saída: `{"month":"5"}` Entrada: `05` Padrão: `%{MONTHNUM:month}` Saída: `{"month":"05"}` |
| MONTHNUM2 | Corresponde a números de meses de dois dígitos de 01 a 12. | 20 | Entrada: `05` Padrão: `%{MONTHNUM2:month}` Saída: `{"month":"05"}` |
| MONTHDAY | Corresponde ao dia do mês de 1 a 31, com zero inicial opcional. | 20 | Entrada: `31` Padrão: `%{MONTHDAY:monthDay}` Saída: `{"monthDay":"31"}` |
| YEAR | Corresponde ao ano em dois ou quatro dígitos | 20 | Entrada: `2024` Padrão: `%{YEAR:year}` Saída: `{"year":"2024"}` Entrada: `24` Padrão: `%{YEAR:year}` Saída: `{"year":"24"}` |
| DAY | Corresponde aos nomes dos dias completos ou abreviados. | 20 | Entrada: `Tuesday` Padrão: `%{DAY:day}` Saída: `{"day":"Tuesday"}` |
| HOUR | Corresponde à hora no formato de 24 horas com um zero (0)0-23 à esquerda opcional. | 20 | Entrada: `22` Padrão: `%{HOUR:hour}` Saída: `{"hour":"22"}` |
| MINUTE | Corresponde aos minutos (00-59). | 20 | Entrada: `59` Padrão: `%{MINUTE:min}` Saída: `{"min":"59"}` |
| SECOND | Corresponde a um número que representa os segundos (0)0-60, opcionalmente seguido por um ponto decimal ou dois pontos e um ou mais dígitos para minutos fracionários | 20 | Entrada: `3` Padrão: `%{SECOND:second}` Saída: `{"second":"3"}` Entrada: `30.5` Padrão: `%{SECOND:minSec}` Saída: `{"minSec":"30.5"}` Entrada: `30:5` Padrão: `%{SECOND:minSec}` Saída: `{"minSec":"30:5"}` |
| TIME | Corresponde a um formato de tempo com horas, minutos e segundos no formato (H)H:mm:(s)s. Os segundos incluem o segundo bissexto (0)0-60. | 20 | Entrada: `09:45:32` Padrão: `%{TIME:time}` Saída: `{"time":"09:45:32"}` |
| DATE\$1US | Corresponde a uma data no formato (M)M/(d)d/(aa)aa ou (M)M-(d)d-(aa)aa. | 20 | Entrada: `11/23/2024` Padrão: `%{DATE_US:date}` Saída: `{"date":"11/23/2024"}` Entrada: `1-01-24` Padrão: `%{DATE_US:date}` Saída: `{"date":"1-01-24"}` |
| DATE\$1EU | Corresponde à data no formato (d)d/(M)M/(aa)aa, (d)d-(M)M-(aa)aa ou (d)d.(M)M.(aa)aa. | 20 | Entrada: `23/11/2024` Padrão: `%{DATE_EU:date}` Saída: `{"date":"23/11/2024"}` Entrada: `1.01.24` Padrão: `%{DATE_EU:date}` Saída: `{"date":"1.01.24"}` |
| ISO8601\$1FUSO HORÁRIO | Corresponde ao deslocamento UTC 'Z' ou ao deslocamento de fuso horário com dois pontos opcionais no formato [\$1-](H)H(:)mm. | 20 | Entrada: `+05:30` Padrão: `%{ISO8601_TIMEZONE:tz}` Saída: `{"tz":"+05:30"}` Entrada: `-530` Padrão: `%{ISO8601_TIMEZONE:tz}` Saída: `{"tz":"-530"}` Entrada: `Z` Padrão: `%{ISO8601_TIMEZONE:tz}` Saída: `{"tz":"Z"}` |
| ISO8601\$1SEGUNDO | Corresponde a um número que representa os segundos (0)0-60, opcionalmente seguido por um ponto decimal ou dois pontos e um ou mais dígitos por segundos fracionários | 20 | Entrada: `60` Padrão: `%{ISO8601_SECOND:second}` Saída: `{"second":"60"}` |
| CARIMBO DE DATA/HORA \$1 ISO8601 | Corresponde ao formato de ISO8601 data e hora (yy) yy- (M) M- (d) dT (H) H:mm: ((s) s) (Z\$1 [\$1-] (H) H:mm) com segundos e fuso horário opcionais. | 20 | Entrada: `2023-05-15T14:30:00+05:30` Padrão: `%{TIMESTAMP_ISO8601:timestamp}` Saída: `{"timestamp":"2023-05-15T14:30:00+05:30"}` Entrada: `23-5-1T1:25+5:30` Padrão: `%{TIMESTAMP_ISO8601:timestamp}` Saída: `{"timestamp":"23-5-1T1:25+5:30"}` Entrada: `23-5-1T1:25Z` Padrão: `%{TIMESTAMP_ISO8601:timestamp}` Saída: `{"timestamp":"23-5-1T1:25Z"}` |
| DATE | Corresponde a uma data no formato dos EUA usando %\$1DATE\$1US\$1 ou no formato da UE usando %\$1DATE\$1EU\$1 | 20 | Entrada: `11/29/2024` Padrão: `%{DATE:date}` Saída: `{"date":"11/29/2024"}` Entrada: `29.11.2024` Padrão: `%{DATE:date}` Saída: `{"date":"29.11.2024"}` |
| DATESTAMP | Corresponde a %\$1DATE\$1 seguido pelo padrão %\$1TIME\$1, separado por espaço ou hífen. | 20 | Entrada: `29-11-2024 14:30:00` Padrão: `%{DATESTAMP:dateTime}` Saída: `{"dateTime":"29-11-2024 14:30:00"}` |
| TZ | Corresponde às abreviações de fuso horário comuns (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC). | 20 | Entrada: `PDT` Padrão: `%{TZ:tz}` Saída: `{"tz":"PDT"}` |
| CARIMBO DE DATA\$1 RFC822 | Corresponde à data e hora no formato: Dia MonthName (D) D (YY) YY (H) H:mm :( s) s Fuso horário | 20 | Entrada: `Monday Jan 5 23 1:30:00 CDT` Padrão: `%{DATESTAMP_RFC822:dateTime}` Saída: `{"dateTime":"Monday Jan 5 23 1:30:00 CDT"}` Entrada: `Mon January 15 2023 14:30:00 PST` Padrão: `%{DATESTAMP_RFC822:dateTime}` Saída: `{"dateTime":"Mon January 15 2023 14:30:00 PST"}` |
| CARIMBO DE DATA\$1 RFC2822 | Corresponde ao formato RFC2822 de data e hora: Dia, (d) d MonthName (yy) yy (H) H:mm :( s) s Z\$1 [\$1-] (H) H:mm | 20 | Entrada: `Mon, 15 May 2023 14:30:00 +0530` Padrão: `%{DATESTAMP_RFC2822:dateTime}` Saída: `{"dateTime":"Mon, 15 May 2023 14:30:00 +0530"}` Entrada: `Monday, 15 Jan 23 14:30:00 Z` Padrão: `%{DATESTAMP_RFC2822:dateTime}` Saída: `{"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}` |
| DATESTAMP\$1OTHER | Corresponde à data e hora no formato: Dia MonthName (d) d (H) H:mm :( s) s Fuso horário (yy) yy | 20 | Entrada: `Mon May 15 14:30:00 PST 2023` Padrão: `%{DATESTAMP_OTHER:dateTime}` Saída: `{"dateTime":"Mon May 15 14:30:00 PST 2023"}` |
| DATESTAMP\$1EVENTLOG | Corresponde ao formato compacto de data e hora sem separadores: (aa)aaMM(d)d(H)Hmm(s)s | 20 | Entrada: `20230515143000` Padrão: `%{DATESTAMP_EVENTLOG:dateTime}` Saída: `{"dateTime":"20230515143000"}` |
**Padrões Grok de log**
| Padrão Grok | Description | Limite máximo de padrões | Exemplo |
| --- | --- | --- | --- |
| LOGLEVEL | Corresponde aos níveis de log padrão em diferentes letras maiúsculas e abreviações, incluindo as seguintes: Alert/ALERT, Trace/TRACE, Debug/DEBUG, Notice/NOTICE, Info/INFO, Warn/Warning/WARN/WARNING, Err/Error/ERR/ERROR, Crit/Critical/CRIT/CRITICAL, Fatal/FATAL, Severe/SEVERE, Emerg/Emergency/EMERG/EMERGENCY | 20 | Entrada: `INFO` Padrão: `%{LOGLEVEL:logLevel}` Saída: `{"logLevel":"INFO"}` |
| HTTPDATE | Corresponde ao formato de data e hora frequentemente usado em arquivos de log. Formato: (d) MonthName d/ (yy) yy :( H) H:mm :( s) s Fuso horário: corresponde aos nomes completos ou abreviados dos meses em inglês (exemplo MonthName: “janeiro” ou “janeiro”) Fuso horário: corresponde ao padrão% \$1INT\$1 grok | 20 | Entrada: `23/Nov/2024:14:30:00 +0640` Padrão: `%{HTTPDATE:date}` Saída: `{"date":"23/Nov/2024:14:30:00 +0640"}` |
| SYSLOGTIMESTAMP | Corresponde ao formato de data com MonthName (d) d (H) H:mm :( s) s MonthName: Corresponde aos nomes completos ou abreviados dos meses em inglês (exemplo: “janeiro” ou “janeiro”) | 20 | Entrada: `Nov 29 14:30:00` Padrão: `%{SYSLOGTIMESTAMP:dateTime}` Saída: `{"dateTime":"Nov 29 14:30:00"}` |
| PROG | Corresponde a um nome de programa que consiste em uma sequência de letras, dígitos, ponto, sublinhado, barra, sinal de porcentagem e caracteres de hífen. | 20 | Entrada: `user.profile/settings-page` Padrão: `%{PROG:program}` Saída: `{"program":"user.profile/settings-page"}` |
| SYSLOGPROG | Corresponde ao padrão Grok PROG opcionalmente seguido por um ID de processo entre colchetes. | 20 | Entrada: `user.profile/settings-page[1234]` Padrão: `%{SYSLOGPROG:programWithId}` Saída: `{"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}` |
| SYSLOGHOST | Corresponde a um padrão %\$1HOST\$1 ou %\$1IP\$1 | 5 | Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Padrão: `%{SYSLOGHOST:ip}` Saída: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| SYSLOGFACILITY | Corresponde à prioridade do syslog no formato decimal. O valor deve estar entre colchetes angulares (<>). | 20 | Entrada: `<13.6>` Padrão: `%{SYSLOGFACILITY:syslog}` Saída: `{"syslog":"<13.6>","facility":"13","priority":"6"}` |
**Padrões Grok de log comum**
Você pode usar padrões Grok personalizados predefinidos para corresponder aos formatos de log Apache, NGINX e protocolo Syslog (RFC 5424). Quando você usa esses padrões específicos, eles devem ser os primeiros em sua configuração correspondente, e nenhum outro padrão pode precedê-los. Além disso, você pode segui-los somente com exatamente um **DADO**. Padrão **GREEDYDATA** ou **GREEDYDATA\$1MULTILINE**,
| Padrão grok | Description | Limite máximo de padrões |
| --- | --- | --- |
| APACHE ACCESS\$1LOG | Corresponde aos logs de acesso do Apache | 1 |
| NGINX\$1ACCESS\$1LOG | Corresponde aos logs de acesso do NGINX | 1 |
| SYSLOG5424 | Corresponde aos logs do protocolo Syslog (RFC 5424) | 1 |
Veja a seguir exemplos válidos e inválidos do uso desses padrões comuns de formato de log.
```
"%{NGINX_ACCESS_LOG} %{DATA}" // Valid
"%{SYSLOG5424}%{DATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{GREEDYDATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{SYSLOG5424}" // Invalid (multiple common log patterns used)
"%{NGINX_ACCESS_LOG} %{NUMBER:num}" // Invalid (Only GREEDYDATA and DATA patterns are supported with common log patterns)
"%{GREEDYDATA:logMsg} %{SYSLOG5424}" // Invalid (GREEDYDATA and DATA patterns are supported only after common log patterns)
```
#### Exemplos comuns de formato de log
##### Exemplo de log do Apache
Log de amostra:
```
127.0.0.1 - - [03/Aug/2023:12:34:56 +0000] "GET /page.html HTTP/1.1" 200 1234
```
Transformador:
```
[
{
"grok": {
"match": "%{APACHE_ACCESS_LOG}"
}
}
]
```
Saída:
```
{
"request": "/page.html",
"http_method": "GET",
"status_code": 200,
"http_version": "1.1",
"response_size": 1234,
"remote_host": "127.0.0.1",
"timestamp": "2023-08-03T12:34:56Z"
}
```
##### Exemplo de log do NGINX
Log de amostra:
```
192.168.1.100 - Foo [03/Aug/2023:12:34:56 +0000] "GET /account/login.html HTTP/1.1" 200 42 "https://www.amazon.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36"
```
Transformador:
```
[
{
"grok": {
"match": "%{NGINX_ACCESS_LOG}"
}
}
]
```
Saída:
```
{
"request": "/account/login.html",
"referrer": "https://www.amazon.com/",
"agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
"http_method": "GET",
"status_code": 200,
"auth_user": "Foo",
"http_version": "1.1",
"response_size": 42,
"remote_host": "192.168.1.100",
"timestamp": "2023-08-03T12:34:56Z"
}
```
##### Exemplo de log do protocolo Syslog (RFC 5424)
Log de amostra:
```
<165>1 2003-10-11T22:14:15.003Z mymachine.example.com evntslog - ID47 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"][examplePriority@32473 class="high"]
```
Transformador:
```
[
{
"grok": {
"match": "%{SYSLOG5424}"
}
}
]
```
Saída:
```
{
"pri": 165,
"version": 1,
"timestamp": "2003-10-11T22:14:15.003Z",
"hostname": "mymachine.example.com",
"app": "evntslog",
"msg_id": "ID47",
"structured_data": "exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"",
"message": "[examplePriority@32473 class=\"high\"]"
}
```
## csv
O processador **csv** analisa valores separados por vírgulas (CSV) dos eventos de logs em colunas.
| Campo | Description | Obrigatório? | Padrão | Limites |
| --- | --- | --- | --- | --- |
| origem | Caminho para o campo no evento de logs que será analisado | Não | `@message` | Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
| delimitador | O caractere usado para separar cada coluna no evento de logs original com valores separados por vírgula | Não | `,` | Comprimento máximo: 1, a menos que o valor seja `\t` ou `\s` |
| quoteCharacter | Caractere usado como qualificador de texto para uma única coluna de dados | Não | `"` | Tamanho máximo: 1 |
| colunas | Lista de nomes a serem usados para as colunas no evento de logs transformado. | Não | `[column_1, column_2 ...]` | Máximo de colunas CSV: 100 Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
| destination | O campo pai em que colocar os pares de valores-chave transformados | Não | `Root node` | Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
Definir `delimiter` como `\t` separará cada coluna em um caractere de tabulação e `\t` separará cada coluna em um único caractere de espaço.
**Exemplo**
Suponha que parte de um evento de logs ingerido seja semelhante a:
```
'Akua Mansa':28:'New York: USA'
```
Suponha que usemos apenas o processador **csv**:
```
[
{
"csv": {
"delimiter": ":",
"quoteCharacter": "'"
}
}
]
```
O evento de logs transformado seria o seguinte.
```
{
"column_1": "Akua Mansa",
"column_2": "28",
"column_3": "New York: USA"
}
```
**Exemplo 2**
Suponha que um evento de logs ingerido seja semelhante a:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"type": "user_data",
"logMsg": "'Akua Mansa':28:'New York: USA'"
}
```
Suponha que analisemos o evento como JSON, eles analisam um campo JSON com o processador **csv, especificando os nomes** e o destino das colunas:
```
[
{
"parseJSON": {}
},
{
"csv": {
"source": "logMsg",
"delimiter": ":",
"quoteCharacter": "'",
"columns":["name","age","location"],
"destination": "msg"
}
}
]
```
O evento de logs transformado seria o seguinte.
```
{
"timestamp": "2024-11-23T16:03:12Z",
"logMsg": "'Akua Mansa':28:'New York: USA'",
"type": "user_data",
"msg": {
"name": "Akua Mansa",
"age": "28",
"location": "New York: USA"
}
}
```
## parseKeyValue
Use o **parseKeyValue**processador para analisar um campo especificado em pares de valores-chave. Você pode personalizar o processador para analisar as informações do campo com as seguintes opções.
| Campo | Description | Obrigatório? | Padrão | Limites |
| --- | --- | --- | --- | --- |
| origem | Caminho para o campo no evento de logs que será analisado | Não | `@message` | Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3 |
| destination | O campo de destino no qual colocar os pares de valores-chave extraídos | Não | | Tamanho máximo: 128 |
| fieldDelimiter | A string delimitadora de campo que é usada entre pares de valores-chave nos eventos de logs originais | Não | `&` | Tamanho máximo: 128 |
| keyValueDelimiter | A string delimitadora a ser usada entre a chave e o valor em cada par no evento de logs transformado | Não | `=` | Tamanho máximo: 128 |
| nonMatchValue | Um valor a ser inserido no campo de valor no resultado, quando um par de valores-chave não é dividido com sucesso. | Não | | Tamanho máximo: 128 |
| keyPrefix | Se você quiser adicionar um prefixo a todas as chaves transformadas, especifique-o aqui. | Não | | Tamanho máximo: 128 |
| overwriteIfExists | Se o valor deve ser substituído caso a chave de destino já exista | Não | `false` | |
**Exemplo**
Observe o seguinte exemplo de evento de logs:
```
key1:value1!key2:value2!key3:value3!key4
```
Suponha que usemos a seguinte configuração de processador:
```
[
{
"parseKeyValue": {
"destination": "new_key",
"fieldDelimiter": "!",
"keyValueDelimiter": ":",
"nonMatchValue": "defaultValue",
"keyPrefix": "parsed_"
}
}
]
```
O evento de logs transformado seria o seguinte.
```
{
"new_key": {
"parsed_key1": "value1",
"parsed_key2": "value2",
"parsed_key3": "value3",
"parsed_key4": "defaultValue"
}
}
```