Processadores configuráveis do tipo analisador Processadores integrados para AWS registros vendidos Processadores de mutação de strings Processadores de mutação JSON Processadores conversores de tipos de dados

Processadores que você pode usar

Esta seção contém informações sobre cada processador que você pode usar em um transformador de eventos de log. Os processadores podem ser categorizados em analisadores, mutadores de string, mutadores JSON e processadores de data.

Sumário

Processadores configuráveis do tipo analisador

parseJSON

O processador parseJSON analisa os eventos de log 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.

O @message conteúdo original não é alterado, as novas chaves são adicionadas à mensagem.

Campo Descrição Obrigatório? Padrão Limites

Campo	Descrição	Obrigatório?	Padrão	Limites
origem	Caminho para o campo no evento de registro 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

origem

Caminho para o campo no evento de registro 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 registro ingerido tenha a seguinte aparência:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

Então, se tivermos esse processador ParseJSON:


[
   "parseJSON": {
        "destination": "new_key"
   }
]

O evento de registro transformado seria o seguinte.


{
    "new_key": {
        "outer_key": {
            "inner_key": "inner_value"
        }
    }
}

grok

Use o processador grok para usar a correspondência de padrões para analisar e estruturar dados não estruturados. Esse processador também pode extrair campos de mensagens de log.

Campo Descrição Obrigatório? Padrão Limites

Campo	Descrição	Obrigatório?	Padrão	Limites
origem	Caminho para o campo no evento de registro ao 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 que corresponde ao evento de log. Os padrões grok suportados estão listados no final desta seção.	Sim		Tamanho máximo: 128 Máximo de 5 padrões grok. Os padrões grok não suportarão conversões de tipo. Para padrões comuns de formato de log (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG,,) SYSLOG5424, somente os padrões GREEDYDATA ou DATA são suportados para serem incluídos após o padrão de log comum.

origem

Caminho para o campo no evento de registro ao 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 que corresponde ao evento de log. Os padrões grok suportados estão listados no final desta seção.

Sim

Tamanho máximo: 128

Máximo de 5 padrões grok. Os padrões grok não suportarão conversões de tipo.

Para padrões comuns de formato de log (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG,,) SYSLOG5424, somente os padrões GREEDYDATA ou DATA são suportados para serem incluídos após o padrão de log comum.

Exemplos de Grok

Exemplo 1: use grok para extrair um campo de registros não estruturados

Registro 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"
}

Exemplo 2

Registro 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 3: use grok em combinação com parseJSON para extrair campos de um evento de log JSON

Registro 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"
}

Padrões grok suportados

As tabelas a seguir listam os padrões suportados pelo grok processador.

Padrões gerais de grok

Padrão	Exemplo	Descrição
NOME DE USUÁRIO ou USUÁRIO	Entrada: `user123.name-TEST` Padrão: `%{USERNAME:name}` Saída: `{"name": "user123.name-TEST"}`	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 (_) ou hífens (-)
INT	Entrada: `-456` Padrão: `%{INT:num}` Saída: `{"num": "-456"}`	Corresponde a um sinal opcional de mais ou menos seguido por um ou mais dígitos.
BASE10NUM	Entrada: `-0.67` Padrão: `%{BASE10NUM:num}` Saída: `{"num": "-0.67"}`	Corresponde a um número inteiro ou de ponto flutuante com sinal e ponto decimal opcionais.
BASE16NUM	Entrada: `+0xA1B2` Padrão: `%{BASE16NUM:num}` Saída: `{"num": "+0xA1B2"}`	Combina números decimais e hexadecimais com um sinal opcional (+ ou -) e um prefixo 0x opcional.
APONTAR	Entrada: `123` Padrão: `%{POSINT:num}` Saída: `{"num": "123"}`	Corresponde a números inteiros positivos sem zeros à esquerda, consistindo em um ou mais dígitos (1-9 seguido por 0-9).
INSIGNIFICANTE	Entrada: `008` Padrão: `%{NONNEGINT:num}` Saída: `{"num": "008"}`	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.
PALAVRA	Entrada: `abc def` Padrão: `%{WORD:user}` Saída: `{"user": "user_123"}`	Corresponde a palavras inteiras compostas por um ou mais caracteres (\ w), incluindo letras, dígitos e sublinhados.
NÃO É ESPAÇO	Entrada: `hello_world123` Padrão: `%{NOTSPACE:msg}` Saída: `{"msg": "hello_world123"}`	Corresponde a um ou mais caracteres sem espaço em branco.
SPACE	Entrada: `" "` Padrão: `%{SPACE:extra}` Saída: `{"extra": " "}`	Corresponde a zero ou mais caracteres de espaço em branco.
DATA	Entrada: `abc def` Padrão: `%{DATA:data}` Saída: `{"data": "abc def"}`	Corresponde a qualquer caractere (exceto a nova linha) zero ou mais vezes, sem ser ganancioso.
DADOS GANANCIOSOS	Entrada: `abc def` Padrão: `%{GREEDYDATA:data}` Saída: `{"data": "abc def"}`	Corresponde a qualquer caractere (exceto a nova linha) zero ou mais vezes, ganancioso.
CADEIA DE CARACTERES ENTRE ASPAS	Entrada: `"Hello, world!` Padrão: `%{QUOTEDSTRING:msg}` Saída: `{"msg": "Hello, world!"}`	Combina cadeias de caracteres entre aspas (aspas simples ou duplas) com caracteres de escape.
UUID	Entrada: `550e8400-e29b-41d4-a716-446655440000` Padrão: `%{UUID:id}` Saída: `{"id": "550e8400-e29b-41d4-a716-446655440000"}`	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 hífens.
URNA	Entrada: `urn:isbn:0451450523` Padrão: `%{URN:urn}` Saída: `{"urn": "urn:isbn:0451450523"}`	Corresponde à sintaxe do Uniform Resource Name (URN).

AWS padrões grok

Padrão Exemplo Descrição

Padrão	Exemplo	Descrição
ARN	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"}`	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.

ARN

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"}

Corresponde aos nomes de recursos da AWS Amazon (ARNs), capturando a partição (aws,aws-cn, ouaws-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.

Padrões de rede Grok

Padrão	Exemplo	Descrição
CISCOMAC	Entrada: `0123.4567.89AB` Padrão: `%{CISCOMAC:MacAddress}` Saída: `{"MacAddress": "0123.4567.89AB"}`	Corresponde a um endereço MAC no formato hexadecimal 4-4-4.
WINDOWSMAC	Entrada: `01-23-45-67-89-AB` Padrão: `%{WINDOWSMAC:MacAddress}` Saída: `{"MacAddress": "01-23-45-67-89-AB"}`	Corresponde a um endereço MAC em formato hexadecimal com hífens.
MAC COMUM	Entrada: `01:23:45:67:89:AB` Padrão: `%{COMMONMAC:MacAddress}` Saída: `{"MacAddress": "01:23:45:67:89:AB"}`	Corresponde a um endereço MAC em formato hexadecimal com dois pontos.
Mac	Entrada: `01:23:45:67:89:AB` Padrão: `%{MAC:m1}` Saída: `{"m1": "01:23:45:67:89:AB"}`	Corresponde a qualquer um dos padrões CISCOMAC, WINDOWSMAC ou COMMONMAC.
IPV6	Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Padrão: `%{IPV6:ip}` Saída: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`	Corresponde a IPv6 endereços, incluindo formulários compactados e endereços IPv4 mapeados IPv6 .
IPV4	Entrada: `192.168.0.1` Padrão: `%{IPV4:ip}` Saída: `{"ip": "192.168.0.1"}`	Corresponde aos IPv4 endereços.
IP	Entrada: `192.168.0.1` Padrão: `%{IP:ip}` Saída: `{"ip": "192.168.0.1"}`	Corresponde aos IPv6 endereços suportados pelo IPV6padrão ou aos IPv4 endereços compatíveis com o IPV4padrão.
NOME DO HOST ou HOST	Entrada: `server-01.internal-network.local` Padrão: `%{HOST:host}` Saída: `{"host": "server-01.internal-network.local"}`	Corresponde a nomes de domínio, incluindo subdomínios.
IP OU HOST	Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Padrão: `%{IPORHOST:ip}` Saída: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`	Corresponde a um nome de host, conforme suportado no padrão HOSTNAME, ou a um endereço IP, conforme suportado no padrão IP.
PORTA DE ACOLHIMENTO	Entrada: `192.168.0.1:8080` Padrão: `%{HOSTPORT:ip}` Saída: `{"ip":"192.168.0.1:8080","PORT":"8080"}`	Corresponde a um endereço IP ou nome de host, conforme suportado pelo padrão IPORHOST seguido por dois pontos e um número de porta, capturando a porta como “PORT” na saída.
URIHOST	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"}`	Corresponde a um endereço IP ou nome de host, conforme suportado pelo padrão IPORHOST, opcionalmente seguido por dois pontos e um número de porta, capturando a porta como “porta”, se presente.

Padrões de Path Grok

Padrão	Exemplo	Descrição
CAMINHO UNIX	Entrada: `/search?q=regex` Padrão: `%{UNIXPATH:path}` Saída: `{"path":"/search?q=regex"}`	Corresponde aos caminhos de URL, incluindo potencialmente parâmetros de consulta.
CAMINHO DA VITÓRIA	Entrada: `C:\Users\John\Documents\file.txt` Padrão: `%{WINPATH:path}` Saída: `{"path": "C:\\Users\\John\\Documents\\file.txt"}`	Corresponde aos caminhos dos arquivos do Windows.
PATH	Entrada: `/search?q=regex` Padrão: `%{PATH:path}` Saída: `{"path":"/search?q=regex"}`	Corresponde aos caminhos do URL ou do arquivo do Windows.
TTY	Entrada: `/dev/tty1` Padrão: `%{TTY:path}` Saída: `{"path":"/dev/tty1"}`	Combina caminhos de dispositivos Unix para terminais e pseudoterminais.
URIPROTO	Entrada: `web+transformer` Padrão: `%{URIPROTO:protocol}` Saída: `{"protocol":"web+transformer"}`	Corresponde às letras, opcionalmente seguidas por um caractere de adição (+) e letras adicionais ou caracteres de adição (+).
URIPATA	Entrada: `/category/sub-category/product_name` Padrão: `%{URIPATH:path}` Saída: `{"path":"/category/sub-category/product_name"}`	Corresponde ao componente de caminho de um URI.
URIPARAM	Entrada: `?param1=value1&param2=value2` Padrão: `%{URIPARAM:url}` Saída: `{"url":"?param1=value1&param2=value2"}`	Corresponde aos parâmetros de consulta de URL.
PARÂMETRO URIPATH	Entrada: `/category/sub-category/product?id=12345&color=red` Padrão: `%{URIPATHPARAM:path}` Saída: `{"path":"/category/sub-category/product?id=12345&color=red"}`	Corresponde a um caminho de URI, opcionalmente seguido por parâmetros de consulta.
URI	Entrada: `https://user:password@example.com/path/to/resource?param1=value1&param2=value2` Padrão: `%{URI:uri` Saída: `{"path":"https://user:password@example.com/path/to/resource?param1=value1&param2=value2"}`	Corresponde a um URI completo.

Padrões de grok de data e hora

Padrão	Exemplo	Descrição
MONTH	Entrada: `Jan` Padrão: `%{MONTH:month}` Saída: `{"month":"Jan"}` Entrada: `January` Padrão: `%{MONTH:month}` Saída: `{"month":"January"}`	Corresponde aos nomes completos ou abreviados dos meses em inglês como palavras inteiras.
MÊS	Entrada: `5` Padrão: `%{MONTHNUM:month}` Saída: `{"month":"5"}` Entrada: `05` Padrão: `%{MONTHNUM:month}` Saída: `{"month":"05"}`	Corresponde aos números dos meses de 1 a 12, com zero inicial opcional para meses de um dígito.
MONTHNUM2	Entrada: `05` Padrão: `%{MONTHNUM2:month}` Saída: `{"month":"05"}`	Corresponde a números mensais de dois dígitos de 01 a 12.
DIA DO MÊS	Entrada: `31` Padrão: `%{MONTHDAY:monthDay}` Saída: `{"monthDay":"31"}`	Corresponde ao dia do mês de 1 a 31, com zero inicial opcional.
YEAR	Entrada: `2024` Padrão: `%{YEAR:year}` Saída: `{"year":"2024"}` Entrada: `24` Padrão: `%{YEAR:year}` Saída: `{"year":"24"}`	Combina anos em formatos de dois ou quatro dígitos.
DAY	Entrada: `Tuesday` Padrão: `%{DAY:day}` Saída: `{"day":"Tuesday"}`	Corresponde aos nomes dos dias completos ou abreviados.
HOUR	Entrada: `22` Padrão: `%{HOUR:hour}` Saída: `{"hour":"22"}`	Combina a hora no formato de 24 horas com um zero (0) 0-23 à esquerda opcional.
MINUTE	Entrada: `59` Padrão: `%{MINUTE:min}` Saída: `{"min":"59"}`	Minutos de partidas (00-59).
SECOND	Entrada: `3` Padrão: `%{SECOND:second}` Saída: `{"second":"3"}` Entrada: `30.5` Padrão: `%{SECOND:fractionalSeconds}` Saída: `{"minSec":"30.5"}` Entrada: `30:5` Padrão: `%{SECOND:fractionalSeconds}` Saída: `{"minSec":"30:5"}`	Corresponde a um número que representa os segundos (0) de 0 a 60, opcionalmente seguido por um ponto decimal ou dois pontos e um ou mais dígitos por segundos fracionários.
TIME	Entrada: `09:45:32` Padrão: `%{TIME:time}` Saída: `{"time":"09:45:32"}`	Corresponde a um formato de hora com horas, minutos e segundos, em que o padrão HOUR corresponde à hora, o padrão MINUTE corresponde ao minuto e o padrão SECOND corresponde ao segundo, normalmente no formato`(H)H:mm:(s)s`. Os segundos incluem segundos bissextos (0) 0-60.
DATE_US	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"}`	Corresponde a uma data no formato de `(M)M/(d)d/(yy)yy` ou`(M)M-(d)d-(yy)yy`, em que o padrão MONTHNUM corresponde ao mês, o padrão MONTHDAY corresponde ao dia e o padrão YEAR corresponde ao ano.
DATE_EU	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"}`	Corresponde a uma data no formato de`d)d/(M)M/(yy)yy`,`(d)d-(M)M-(yy)yy`, ou`(d)d.(M)M.(yy)yy`, em que o padrão MONTHNUM corresponde ao mês, o padrão MONTHDAY corresponde ao dia e o padrão YEAR corresponde ao ano.
DATA	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"}`	Corresponde a uma data no formato dos EUA ou da UE, como nos padrões DATE_US e DATE_EU.
CARIMBO DE DATA	Entrada: `29-11-2024 14:30:00` Padrão: `%{DATESTAMP:dateTime}` Saída: `{"dateTime":"29-11-2024 14:30:00"}`	Corresponde a um padrão DATE seguido por um padrão TIME, separado por um espaço ou um hífen.
TZ	Entrada: `PDT` Padrão: `%{TZ:tz}` Saída: `{"tz":"PDT"}`	Corresponde às abreviações de fuso horário comuns (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC).
ISO8601_FUSO HORÁRIO	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"}`	Combina o deslocamento UTC 'Z' ou o deslocamento de fuso horário com dois pontos opcionais neste formato: `[+-](H)H(:)mm` w onde o padrão HOUR corresponde à hora e o padrão MINUTE corresponde aos minutos.
ISO8601_SEGUNDO	Entrada: `60` Padrão: `%{ISO8601_SECOND:second}` Saída: `{"second":"60"}`	Corresponde a um número que representa os segundos (0) de 0 a 60, opcionalmente seguido por um ponto decimal ou dois pontos e um ou mais dígitos por segundos fracionários.
TIMESTAMP _ 01 ISO86	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"}`	Corresponde ao formato de data e hora ISO86 01 `(yy)yy-(M)M-(d)dT(H)H:mm:((s)s)(Z\|[+-](H)H:mm)` com segundos e fuso horário opcionais.
CARIMBO DE DATA_ RFC2822	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:timestamp}` Saída: `{"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}`	Corresponde ao RFC2822 formato de data e hora: `Day, (d)d MonthName (yy)yy (H)H:mm:(s)s Z\|[+-](H)H:mm` `Day`o padrão é usado para corresponder a um dia completo ou abreviado, como “segunda-feira” ou “segunda-feira”. `MonthName`O padrão é usado para combinar nomes de meses completos ou abreviados em inglês, como “Jan” ou “January”. `Timezone`o padrão é usado para combinar o deslocamento UTC (Z) ou o deslocamento do fuso horário com dois pontos opcionais.
DATESTAMP_OUTRO	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"}`	Combina data e hora no seguinte formato: `Day MonthName (d)d (H)H:mm:(s)s Timezone (yy)yy` O padrão Dia é usado para corresponder ao dia completo ou abreviado, como “segunda-feira” ou “segunda-feira”. O MonthNamepadrão é usado para combinar nomes completos ou abreviados dos meses em inglês, como “Jan” ou “January”. `Day`o padrão é usado para corresponder a um dia completo ou abreviado, como “segunda-feira” ou “segunda-feira”. `MonthName`O padrão é usado para combinar nomes de meses completos ou abreviados em inglês, como “Jan” ou “January”. `Timezone`O padrão corresponde a qualquer fuso horário compatível com o padrão TZ grok.
DATESTAMP_EVENTLOG	Entrada: `20230515143000` Padrão: `%{DATESTAMP_EVENTLOG:dateTime}` Saída: `{"dateTime":"20230515143000"}`	Corresponde a um formato compacto de data e hora sem separadores: `(yy)yyMM(d)d(H)Hmm(s)s`

Padrões de grok longo

Padrão	Exemplo	Descrição
NÍVEL DE REGISTRO	Entrada: `INFO` Padrão: `%{LOGLEVEL:logLevel}` Saída: `{"logLevel":"INFO"}`	Corresponde aos níveis de registro padrão em diferentes maiúsculas e abreviações, incluindo as seguintes:,,`Alert/ALERT`,,,,`Trace/TRACE`,`Debug/DEBUG`,`Notice/NOTICE`,, `Info/INFOWarn/Warning/WARN/WARNING`,`Err/Error/ERR/ERROR`. `Crit/Critical/CRIT/CRITICAL` `Fatal/FATAL` `Severe/SEVERE` `Emerg/Emergency/EMERG/EMERGENCY`
DATA HTTP	Entrada: `23/Nov/2024:14:30:00 +0640` Padrão: `%{HTTPDATE:date}` Saída: `{"date":"23/Nov/2024:14:30:00 +0640"}`	Corresponde ao formato de data e hora frequentemente usado em arquivos de log. Formato: `(d)d/MonthName/(yy)yy:(H)H:mm:(s)s Timezone` `MonthName`corresponde aos nomes completos ou abreviados dos meses em inglês, como “Jan” ou “January”, e `Timezone` corresponde ao padrão INT grok.
CARIMBO DE DATA/HORA DO SYSLOG	Entrada: `Nov 29 14:30:00` Padrão: `%{SYSLOGTIMESTAMP:dateTime}` Saída: `{"dateTime":"Nov 29 14:30:00"}`	Combina o formato de data com`MonthName (d)d (H)H:mm:(s)s`. `MonthName`corresponde aos nomes completos ou abreviados dos meses em inglês, como “Jan” ou “January”
PROGRESSIVO	Entrada: `user.profile/settings-page` Padrão: `%{PROG:program}` Saída: `{"program":"user.profile/settings-page"}`	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.
SYSLOGPROG	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"}`	Corresponde ao padrão PROG grok, opcionalmente seguido por um ID de processo entre colchetes.
SYSLOGHOST	Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Padrão: `%{SYSLOGHOST:ip}` Saída: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`	Corresponde a um padrão HOST ou IP.
INSTALAÇÃO DE SYSLOG	Entrada: `<13.6>` Padrão: `%{SYSLOGFACILITY:syslog}` Saída: `{"syslog":"<13.6>","facility":"13","priority":"6"}`	Corresponde à prioridade do syslog no formato decimal. O valor deve estar entre colchetes angulares (<>).

Padrões comuns de troncos

Você pode usar padrões grok personalizados predefinidos que podem ser usados para combinar os formatos de log Apache, NGINX e Syslog Protocol (RFC 5424). Quando você usa esses padrões específicos, eles devem ser os primeiros padrões em sua configuração correspondente, e nenhum outro padrão pode precedê-los. Além disso, você pode segui-los somente com o padrão GREEDYDATA ou DATA.

Padrão	Descrição	Limite de uso dentro do `match` campo
LOG_DE_ACESSO DO APACHE	Corresponde aos registros de acesso do Apache	1
NGINX_ACCESS_LOG	Corresponde aos registros de acesso do NGINX	1
SYSLOG5424	Corresponde aos registros 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

Registro 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:


{
  "remote_host": "127.0.0.1",
  "ident": "-",
  "auth_user": "-",
  "timestamp": "2023-08-03T12:34:56Z",
  "http_method": "GET",
  "request": "/page.html",
  "http_version": 1.1,
  "status_code": 200,
  "response_size": 1234
}

Exemplo de log do NGINX

Registro 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:


{
  "remote_host": "192.168.1.100",
  "ident": "-",
  "auth_user": "Foo",
  "timestamp": "2023-08-03T12:34:56Z",
  "http_method": "GET",
  "request": "/account/login.html",
  "http_version": 1.1,
  "status_code": 200,
  "response_size": 42,
  "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"
}

Exemplo de log do protocolo Syslog (RFC 5424)

Registro 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írgula (CSV) dos eventos de registro em colunas.

Campo	Descrição	Obrigatório?	Padrão	Limites
origem	Caminho para o campo no evento de registro 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 original de registro de valores separados por vírgula	Não	`,`	Comprimento máximo: 1
Cite o personagem	Caractere usado como qualificador de texto para uma única coluna de dados	Não	`"`	Comprimento máximo: 1
colunas	Lista de nomes a serem usados para as colunas no evento de registro transformado.	Não	`[column_1, column_2 ...]`	Máximo de colunas CSV: 100 Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3

Exemplo

Suponha que parte de um evento de registro ingerido tenha a seguinte aparência:


'Akua Mansa',28,'New York, USA'

Suponha que usemos apenas o processador csv:


[
   "csv": {
      "delimiter": ":",
      "quoteCharacter": ":""
   }
]

O evento de registro transformado seria o seguinte.


{
  "column_1": "Akua Mansa",
  "column_2": "28",
  "column_3": "New York, USA"
}

parseKeyValue

Use o parseKeyValueprocessador 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	Descrição	Obrigatório?	Padrão	Limites
origem	Caminho para o campo no evento de registro 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
Delimitador de campo	A string delimitadora de campo que é usada entre pares de valores-chave nos eventos de log 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 log 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 se a chave de destino já existir	Não	`false`

Exemplo

Veja o seguinte exemplo de evento de log:


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 registro transformado seria o seguinte.


{
  "new_key": {
    "parsed_key1": "value1",
    "parsed_key2": "value2",
    "parsed_key3": "value3",
    "parsed_key4": "defaultValue"
  }
}

Processadores integrados para AWS registros vendidos

Analisar WAF

Use esse processador para analisar registros vendidos. Ele pega o conteúdo httpRequest.headers e cria chaves JSON a partir de cada nome de cabeçalho, com o AWS WAF valor correspondente. Também faz o mesmo paralabels. Essas transformações podem facilitar muito a consulta aos AWS WAF registros. Para obter mais informações sobre o formato de AWS WAF log, consulte Exemplos de log para tráfego de ACL da web.

Esse processador aceita somente @message como entrada.

Importante

Se você usa esse processador, ele deve ser o primeiro processador em seu transformador.

Exemplo

Veja o seguinte exemplo de evento de log:


{
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": [],
  "httpRequest": {
    "clientIp": "1.1.1.1",
    "country": "AU",
    "headers": [
      { "name": "Host", "value": "localhost:1989" },
      { "name": "User-Agent", "value": "curl/7.61.1" },
      { "name": "Accept", "value": "*/*" },
      { "name": "x-stm-test", "value": "10 AND 1=1" }
    ],
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": [{ "name": "value" }]
}

A configuração do processador é a seguinte:


[
   "parseWAF": {}
]

O evento de registro transformado seria o seguinte.


{
  "httpRequest": {
    "headers": {
      "Host": "localhost:1989",
      "User-Agent": "curl/7.61.1",
      "Accept": "*/*",
      "x-stm-test": "10 AND 1=1"
    },
    "clientIp": "1.1.1.1",
    "country": "AU",
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": { "name": "value" },
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": []
}

Analisar Postgres

Use esse processador para analisar Amazon RDS for PostgreSQL registros vendidos, extrair campos e convertê-los para o formato JSON. Para obter mais informações sobre o formato de log do RDS para PostgreSQL, consulte RDS para arquivos de log do banco de dados PostgreSQL.

Esse processador aceita somente @message como entrada.

Importante

Se você usa esse processador, ele deve ser o primeiro processador em seu transformador.

Exemplo

Veja o seguinte exemplo de evento de log:


2019-03-10 03:54:59 UTC:10.0.0.123(52834):postgres@logtestdb:[20175]:ERROR: column "wrong_column_name" does not exist at character 8

A configuração do processador é a seguinte:


[
   "parsePostgres": {}
]

O evento de registro transformado seria o seguinte.


{
  "logTime": "2019-03-10 03:54:59 UTC",
  "srcIp": "10.0.0.123(52834)",
  "userName": "postgres",
  "dbName": "logtestdb",
  "processId": "20175",
  "logLevel": "ERROR"
}

Analise o CloudFront

Use esse processador para analisar Amazon CloudFront registros vendidos, extrair campos e convertê-los em formato JSON. Os valores de campo codificados são decodificados. Valores que são números inteiros e duplos são tratados como tal. Para obter mais informações sobre o formato do Amazon CloudFront registro, consulte Configurar e usar registros padrão (registros de acesso).

Esse processador aceita somente @message como entrada.

Importante

Se você usa esse processador, ele deve ser o primeiro processador em seu transformador.

Exemplo

Veja o seguinte exemplo de evento de log:


2019-12-04  21:02:31   LAX1   392    192.0.2.24    GET    d111111abcdef8.cloudfront.net  /index.html    200    -  Mozilla/5.0%20(Windows%20NT%2010.0;%20Win64;%20x64)%20AppleWebKit/537.36%20(KHTML,%20like%20Gecko)%20Chrome/78.0.3904.108%20Safari/537.36  -  -  Hit    SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==   d111111abcdef8.cloudfront.net  https  23 0.001  -  TLSv1.2    ECDHE-RSA-AES128-GCM-SHA256    Hit    HTTP/2.0   -  -  11040  0.001  Hit    text/html  78 -  -

A configuração do processador é a seguinte:


[
   "parseCloudfront": {}
]

O evento de registro transformado seria o seguinte.


{
  "date": "2019-12-04",
  "time": "21:02:31",
  "x-edge-location": "LAX1",
  "sc-bytes": 392,
  "c-ip": "192.0.2.24",
  "cs-method": "GET",
  "cs(Host)": "d111111abcdef8.cloudfront.net",
  "cs-uri-stem": "/index.html",
  "sc-status": 200,
  "cs(Referer)": "-",
  "cs(User-Agent)": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36",
  "cs-uri-query": "-",
  "cs(Cookie)": "-",
  "x-edge-result-type": "Hit",
  "x-edge-request-id": "SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==",
  "x-host-header": "d111111abcdef8.cloudfront.net",
  "cs-protocol": "https",
  "cs-bytes": 23,
  "time-taken": 0.001,
  "x-forwarded-for": "-",
  "ssl-protocol": "TLSv1.2",
  "ssl-cipher": "ECDHE-RSA-AES128-GCM-SHA256",
  "x-edge-response-result-type": "Hit",
  "cs-protocol-version": "HTTP/2.0",
  "fle-status": "-",
  "fle-encrypted-fields": "-",
  "c-port": 11040,
  "time-to-first-byte": 0.001,
  "x-edge-detailed-result-type": "Hit",
  "sc-content-type": "text/html",
  "sc-content-len": 78,
  "sc-range-start": "-",
  "sc-range-end": "-"
}

ParseRoute 53

Use esse processador para analisar Amazon Route 53 Public Data Plane registros vendidos, extrair campos e convertê-los em formato JSON. Os valores de campo codificados são decodificados.

Esse processador aceita somente @message como entrada.

Importante

Se você usa esse processador, ele deve ser o primeiro processador em seu transformador.

Exemplo

Veja o seguinte exemplo de evento de log:


1.0 2017-12-13T08:15:50.235Z Z123412341234 example.com AAAA NOERROR TCP IAD12 192.0.2.0 198.51.100.0/24

A configuração do processador é a seguinte:


[
   "parseRoute53": {}
]

O evento de registro transformado seria o seguinte.


{
  "version": 1.0,
  "queryTimestamp": "2017-12-13T08:15:50.235Z",
  "hostZoneId": "Z123412341234",
  "queryName": "example.com",
  "queryType": "AAAA",
  "responseCode": "NOERROR",
  "protocol": "TCP",
  "edgeLocation": "IAD12",
  "resolverIp": "192.0.2.0",
  "ednsClientSubnet": "198.51.100.0/24"
}

Analisar VPC

Use esse processador para analisar registros vendidos de Amazon Route 53 Public Data Plane VPC, extrair campos e convertê-los em formato JSON. Os valores de campo codificados são decodificados.

Esse processador aceita somente @message como entrada.

Importante

Se você usa esse processador, ele deve ser o primeiro processador em seu transformador.

Exemplo

Veja o seguinte exemplo de evento de log:


2 123456789010 eni-abc123de 192.0.2.0 192.0.2.24 20641 22 6 20 4249 1418530010 1418530070 ACCEPT OK

A configuração do processador é a seguinte:


[
   "parseVPC": {}
]

O evento de registro transformado seria o seguinte.


{
  "version": 2,
  "accountId": "123456789010",
  "interfaceId": "eni-abc123de",
  "srcAddr": "192.0.2.0",
  "dstAddr": "192.0.2.24",
  "srcPort": 20641,
  "dstPort": 22,
  "protocol": 6,
  "packets": 20,
  "bytes": 4249,
  "start": 1418530010,
  "end": 1418530070,
  "action": "ACCEPT",
  "logStatus": "OK"
}

Processadores de mutação de strings

lowerCaseString

O lowerCaseString processador converte uma string em sua versão em minúsculas.

Campo	Descrição	Obrigatório?	Padrão	Limites
Com chaves	Uma lista de teclas para converter em minúsculas	Sim		Máximo de entradas: 10

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "INNER_VALUE"
    }
}

A configuração do transformador é esta, usando lowerCaseString comparseJSON:


[
   "parseJSON": {},
    "lowerCaseString": {
        "withKeys":["outer_key.inner_key"]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key": "inner_value"
  }
}

upperCaseString

O upperCaseString processador converte uma string em sua versão maiúscula.

Campo	Descrição	Obrigatório?	Padrão	Limites
Com chaves	Uma lista de teclas para converter em maiúsculas	Sim		Máximo de entradas: 10

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando upperCaseString comparseJSON:


[
   "parseJSON": {},
    "upperCaseString": {
        "withKeys":["outer_key.inner_key"]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key": "INNER_VALUE"
  }
}

SplitString

O splitString processador divide um campo em uma matriz usando um caractere delimitador.

Campo	Descrição	Obrigatório?	Limites
entries	Matriz de entradas. Cada item na matriz deve conter `source` `delimiter` campos.	Sim	Máximo de entradas: 100
origem	A chave para dividir	Sim	Tamanho máximo: 128
delimitador	Os caracteres separadores responsáveis pela divisão	Sim	Comprimento máximo: 1

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando splitString comparseJSON:


[
   "parseJSON": {},
    "splitString": {
        "entries": [
            {
                "source": "outer_key.inner_key",
                "delimiter": "_"
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key": [
      "inner",
      "value"
    ]
  }
}

Cadeia de caracteres substituta

O substituteString processador compara o valor de uma chave com uma expressão regular e substitui todas as correspondências por uma string de substituição.

Campo	Descrição	Obrigatório?	Limites
entries	Matriz de entradas. Cada item na matriz deve conter `to` campos `sourcefrom`, e.	Sim	Máximo de entradas: 10
origem	A chave para modificar	Sim	Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
from	A string de expressão regular a ser substituída. Caracteres regex especiais, como [e], devem ser escapados usando\\ ao usar aspas duplas e com\ ao usar aspas simples. Para obter mais informações, consulte Padrão de classe no site da Oracle.	Sim	Tamanho máximo: 128
com	A string a ser substituída por cada partida de `from`	Sim	Tamanho máximo: 128

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key1": "[]",
        "inner_key2": "123-345-567"
    }
}

A configuração do transformador é esta, usando substituteString comparseJSON:


[
   "parseJSON": {},
    "substituteString": {
        "entries": [
            {
                "source": "outer_key.inner_key1",
                "from": "\\[\\]",
                "to": "value1"
            },
            {
                "source": "outer_key.inner_key2",
                "from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
                "to": "xxx-xxx-xxx"            
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key1": "value1",
    "inner_key2": "xxx-xxx-xxx"
  }
}

Trim String

O trimString processador remove os espaços em branco do início e do final de uma chave.

Campo	Descrição	Obrigatório?	Padrão	Limites
Com chaves	Uma lista de teclas para cortar	Sim		Máximo de entradas: 10

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "   inner_value  "
    }
}

A configuração do transformador é esta, usando trimString comparseJSON:


[
   "parseJSON": {},
    "trimString": {
        "withKeys":["outer_key.inner_key"]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key": "inner_value"
  }
}

Processadores de mutação JSON

Adicionar chaves

Use o addKeys processador para adicionar novos pares de valores-chave ao evento de registro.

Campo	Descrição	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter`key`,`value`, e `overwriteIfExists` campos.	Sim		Máximo de entradas: 5
key	A chave da nova entrada a ser adicionada	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
valor	O valor da nova entrada a ser adicionada	Sim		Comprimento máximo: 256
overwriteIfExists	Se você definir isso como`true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando addKeys comparseJSON:


[
   "parseJSON": {},
   "addKeys": {
        "entries": [
            {
                "source": "outer_key.new_key",
                "value": "new_value"
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key": "inner_value",
    "new_key": "new_value"
  }
}

Excluir chaves

Use o deleteKeys processador para excluir campos de um evento de registro. Esses campos podem incluir pares de valores-chave.

Campo	Descrição	Obrigatório?	Padrão	Limites
Com chaves	A lista de chaves a serem excluídas.	Sim		Máximo de entradas: 5

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando deleteKeys comparseJSON:


[
   "parseJSON": {},
    "deleteKeys": {
        "withKeys":["outer_key.inner_key"]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {}
}

Teclas de movimento

Use o moveKeys processador para mover uma chave de um campo para outro.

Campo	Descrição	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter`source`,`target`, e `overwriteIfExists` campos.	Sim		Máximo de entradas: 5
origem	A chave para se mover	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
target	A chave para ir para	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
overwriteIfExists	Se você definir isso como`true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key1": {
        "inner_key1": "inner_value1"
    },
    "outer_key2": {
        "inner_key2": "inner_value2"
    }
}

A configuração do transformador é esta, usando moveKeys comparseJSON:


[
   "parseJSON": {},
   "moveKeys": {
        "entries": [
            {
                "source": "outer_key1.inner_key1",
                "target": "outer_key2"
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key1": {},
  "outer_key2": {
    "inner_key2": "inner_value2",
    "inner_key1": "inner_value1"
  }
}

Renomear chaves

Use o renameKeys processador para renomear as chaves em um evento de registro.

Campo	Descrição	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter`key`,`target`, e `overwriteIfExists` campos.	Sim		Máximo de entradas: 5
key	A chave para renomear	Sim		Tamanho máximo: 128
target	O novo nome da chave	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
overwriteIfExists	Se você definir isso como`true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando renameKeys comparseJSON:


[
   "parseJSON": {},
   "renameKeys": {
        "entries": [
            {
                "key": "outer_key",
                "target": "new_key"
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
  "new_key": {
    "inner_key": "inner_value"
  }
}

Valor da cópia

Use o copyValue processador para copiar valores em um evento de log. Você também pode usar esse processador para adicionar metadados aos eventos de log, copiando os valores das seguintes chaves de metadados nos eventos de log:@logGroupName,,@logGroupStream,@accountId. @regionName Isso é ilustrado no exemplo a seguir.

Campo	Descrição	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter`source`,`target`, e `overwriteIfExists` campos.	Sim		Máximo de entradas: 5
origem	A chave para copiar	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
target	A chave para a qual copiar o valor	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
overwriteIfExists	Se você definir isso como`true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

A configuração do transformador é esta, usando copyValue comparseJSON:


[
   "parseJSON": {},
   "copyValue": {
        "entries": [
            {
                "source": "outer_key.new_key",
                "target": "new_key"
            },
            {
                "source": "@logGroupName",
                "target": "log_group_name"
            },
            {
                "source": "@logGroupStream",
                "target": "log_group_stream"
            },
            {
                "source": "@accountId",
                "target": "account_id"
            },
            {
                "source": "@regionName",
                "target": "region_name"
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
  "outer_key": {
    "inner_key": "inner_value"
  },
  "new_key": "inner_value",
  "log_group_name": "myLogGroupName",
  "log_group_stream": "myLogStreamName",
  "account_id": "012345678912",
  "region_name": "us-east-1"
}

listToMap

O listToMap processador pega uma lista de objetos que contêm campos-chave e os converte em um mapa das teclas de destino.

Campo	Descrição	Obrigatório?	Padrão	Limites
origem	A chave no ProcessingEvent com uma lista de objetos que serão convertidos em um mapa	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
key	A chave dos campos a serem extraídos como chaves no mapa gerado	Sim		Tamanho máximo: 128
Chave de valor	Se isso for especificado, os valores especificados nesse parâmetro serão extraídos dos `source` objetos e colocados nos valores do mapa gerado. Caso contrário, os objetos originais na lista de fontes serão colocados nos valores do mapa gerado.	Não		Tamanho máximo: 128
target	A chave do campo que conterá o mapa gerado	Não	Nó raiz	Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
nivelamento	Um valor booleano para indicar se a lista será nivelada em itens únicos ou se os valores no mapa gerado serão listas. Por padrão, os valores das chaves correspondentes serão representados em uma matriz. `flatten`Defina como `true` para converter a matriz em um único valor com base no valor de`flattenedElement`.	Não	false
Elemento achatado	Se você `flatten` definir como`true`, use `flattenedElement` para especificar qual elemento, `first` ou`last`, manter.	Obrigatório quando `flatten` está definido como `true`		O valor só pode ser `first` ou `last`

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ]
}

Transformador para caso de uso 1: flatten é false


[
   "parseJSON": {},
   "listToMap": {
        "source": "outer_key"
        "key": "inner_key",
        "valueKey": "inner_value",
        "flatten": false
    }
]

O evento de registro transformado seria o seguinte.


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": [
        "val-a"
    ],
    "b": [
        "val-b1",
        "val-b2"
    ],
    "c": [
        "val-c"
    ]
}

Transformador para o caso de uso 2: flatten é true e flattenedElement é first


[
   "parseJSON": {},
   "listToMap": {
        "source": "outer_key"
        "key": "inner_key",
        "valueKey": "inner_value",
        "flatten": true,
        "flattenedElement": "first"
    }
]

O evento de registro transformado seria o seguinte.


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": "val-a",
    "b": "val-b1",
    "c": "val-c"
}

Transformador para o caso de uso 3: flatten é true e flattenedElement é last


[
   "parseJSON": {},
   "listToMap": {
        "source": "outer_key"
        "key": "inner_key",
        "valueKey": "inner_value",
        "flatten": true,
        "flattenedElement": "last"
    }
]

O evento de registro transformado seria o seguinte.


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": "val-a",
    "b": "val-b2",
    "c": "val-c"
}

Processadores conversores de tipos de dados

Conversor de tipo

Use o typeConverter processador para converter um tipo de valor associado à chave especificada para o tipo especificado. É um processador de conversão que altera os tipos dos campos especificados. Os valores podem ser convertidos em um dos seguintes tipos de dados:integer, e. double string boolean

Campo Descrição Obrigatório? Padrão Limites

Campo	Descrição	Obrigatório?	Limites
entries	Matriz de entradas. Cada item na matriz deve conter `key` `type` campos.	Sim	Máximo de entradas: 10
key	A chave com o valor que deve ser convertido em um tipo diferente	Sim	Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
type	O tipo para o qual converter. Os valores válidos são `integer`, `double`, `string` e `boolean`.	Sim

entries

Matriz de entradas. Cada item na matriz deve conter key type campos.

Sim

Máximo de entradas: 10

key

A chave com o valor que deve ser convertido em um tipo diferente

Sim

Tamanho máximo: 128

Profundidade máxima de chave aninhada: 3

type

O tipo para o qual converter. Os valores válidos são integer, double, string e boolean.

Sim

Exemplo

Veja o seguinte exemplo de evento de log:


{
    "name": "value",
    "status": "200"
}

A configuração do transformador é esta, usando typeConverter comparseJSON:


[
   "parseJSON": {},
   "typeConverter": {
        "entries": [
            {
                "key": "status",
                "type": "integer"
            }
        ]
    }
]

O evento de registro transformado seria o seguinte.


{
    "name": "value",
    "status": 200
}

Conversor de data e hora

Use o datetimeConverter processador para converter uma string de data e hora em um formato que você especificar.

Campo	Descrição	Obrigatório?	Padrão	Limites
origem	A chave para aplicar a conversão de data.	Sim		Máximo de entradas: 10
Padrões de correspondência	Uma lista de padrões para combinar com o `source` campo	Sim		Máximo de entradas: 5
target	O campo JSON no qual armazenar o resultado.	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
Formato de destino	O formato de data e hora a ser usado para os dados convertidos no campo de destino.	Não	`yyyy-MM-dd'T'HH:mm:ss.SSS'Z`	Comprimento máximo: 64
Fuso horário de origem	O fuso horário do campo de origem. Para obter uma lista de valores possíveis, consulte Ids e deslocamentos de zona suportados por Java.	Não	UTC	Comprimento mínimo: 1
Fuso horário de destino	O fuso horário do campo de destino. Para obter uma lista de valores possíveis, consulte Ids e deslocamentos de zona suportados por Java.	Não	UTC	Comprimento mínimo: 1
locale	A localidade do campo de origem. Para obter uma lista de valores possíveis, consulte o Método Locale getAvailableLocales () em Java com exemplos.	Sim		Comprimento mínimo: 1

Exemplo

Veja o seguinte exemplo de evento de log:


{"german_datetime": "Samstag 05. Dezember 1998 11:00:00"}

A configuração do transformador é esta, usando dateTimeConverter comparseJSON:


[
   "parseJSON": {},
   "dateTimeConverter": {
        "source": "german_datetime",
        "target": "target_1",
        "locale": "de",
        "matchPatterns": ["EEEE dd. MMMM yyyy HH:mm:ss"],
        "sourceTimezone": "Europe/Berlin",
        "targetTimezone": "America/New_York",
        "targetFormat": "yyyy-MM-dd'T'HH:mm:ss z"
    }
]

O evento de registro transformado seria o seguinte.


{
    "german_datetime": "Samstag 05. Dezember 1998 11:00:00",
    "target_1": "1998-12-05T17:00:00 MEZ"
}

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

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

Convenções do documento

Excluir um transformador de log

Métricas e erros de transformação