Processadores que você pode usar - CloudWatch Registros da Amazon

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 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.

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. Ao usar parseJSON como primeiro processador, você deve analisar todo o evento de log usando @message como campo de origem. Após a análise inicial do JSON, você pode manipular campos específicos nos processadores subsequentes.

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

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

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 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 Descrição 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 log

Sim

Comprimento máximo: 512

Padrões máximos de 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: {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE}

Os padrões Grok não oferecem suporte a conversões de tipos.

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

Veja todos os padrões Grok compatíveis

Estrutura de um padrão Grok

Esta é a estrutura do padrão grok suportada:

%{PATTERN_NAME:FIELD_NAME}
  • PATTERN_NAME: refere-se a uma expressão regular predefinida para corresponder a um tipo específico de dados. Somente padrões de grok predefinidos da lista de padrões de grok suportados são suportados. Não é permitido criar padrões personalizados.

  • FIELD_NAME: 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 log transformado. Se FIELD_NAME usa notação pontilhada (por exemplo, “parent.child”), é considerado um caminho JSON.

  • Conversão de tipo: conversões de tipo explícitas não são suportadas. Use o TypeConverter processador 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 longo. 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 registro lenta do Redis, como esta:

1629860738.123456 [0 127.0.0.1:6379] "SET" "key1" "value1"

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

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 2: 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" }
Exemplo 3: padrão Grok com anotação pontilhada em FIELD_NAME

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

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

Padrões gerais de grok

Padrão Grok Descrição Limite máximo de padrão Exemplo
NOME DE USUÁRIO ou USUÁRIO 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 (-) 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 (+ ou -) e um prefixo 0x opcional 20

Entrada: +0xA1B2

Padrão: %{BASE16NUM:num}

Saída: {"num": "+0xA1B2"}

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

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

PALAVRA Corresponde a palavras inteiras compostas por um ou mais caracteres (\ w), incluindo letras, dígitos e sublinhados 20

Entrada: user_123

Padrão: %{WORD:user}

Saída: {"user": "user_123"}

NÃO ESPAÇO Corresponde a um ou mais caracteres sem espaço 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 a nova linha) zero ou mais vezes, sem ser ganancioso. 5

Entrada: abc def ghi

Padrão: %{DATA:x} %{DATA:y}

Saída: {"x": "abc", "y": "def ghi"}

DADOS GANANCIOSOS Corresponde a qualquer caractere (exceto a nova linha) zero ou mais vezes, ganancioso. 5

Entrada: abc def ghi

Padrão: %{GREEDYDATA:x} %{GREEDYDATA:y}

Saída: {"x": "abc def", "y": "ghi"}

GREEDYDATA_MULTILINE Corresponde a qualquer caractere (incluindo nova linha) zero ou mais vezes, ganancioso. 1

Entrada:

abc

def

ghi

Padrão: %{GREEDYDATA_MULTILINE:data}

Saída: {"data": "abc\ndef\nghi"}

CADEIA DE CARACTERES ENTRE ASPAS 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 hífens. 20

Entrada: 550e8400-e29b-41d4-a716-446655440000

Padrão: %{UUID:id}

Saída: {"id": "550e8400-e29b-41d4-a716-446655440000"}

URNA 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 Descrição Limite máximo de padrão Exemplo

ARN

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.

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 de rede Grok

Padrão Grok Descrição Limite máximo de padrão 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 hífens 20

Entrada: 01-23-45-67-89-AB

Padrão: %{WINDOWSMAC:MacAddress}

Saída: {"MacAddress": "01-23-45-67-89-AB"}

MAC COMUM 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% {IPv6} ou aos IPv4 endereços compatíveis com% {IPv4} 5

Entrada: 192.168.0.1

Padrão: %{IP:ip}

Saída: {"ip": "192.168.0.1"}

NOME DO HOST 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"}

IP OU HOST 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"}

PORTA DE ACOLHIMENTO 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. 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% {IPORHOST}, opcionalmente seguido por dois pontos e um número de porta, capturando a porta como “porta”, 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 Path Grok

Padrão Grok Descrição Limite máximo de padrão Exemplo
CAMINHO UNIX 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"}

CAMINHO DA VITÓRIA 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 (+) e letras adicionais ou caracteres de adição (+) 20

Entrada: web+transformer

Padrão: %{URIPROTO:protocol}

Saída: {"protocol":"web+transformer"}

URIPATA 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&param2=value2

Padrão: %{URIPARAM:url}

Saída: {"url":"?param1=value1&param2=value2"}

PARÂMETRO URIPATH 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&param2=value2

Padrão: %{URI:uri}

Saída: {"path":"https://user:password@example.com/path/to/resource?param1=value1&param2=value2"}

Padrões de grok de data e hora

Padrão Grok Descrição Limite máximo de padrão 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"}

MÊS 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 mensais de dois dígitos de 01 a 12. 20

Entrada: 05

Padrão: %{MONTHNUM2:month}

Saída: {"month":"05"}

DIA DO MÊS 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 Combina a 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 Minutos de partidas (00-59). 20

Entrada: 59

Padrão: %{MINUTE:min}

Saída: {"min":"59"}

SECOND 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 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 hora 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_US Corresponde a uma data no formato de (M) M/ (d) d/ (yy) yy ou (M) M- (d) d- (yy) yy. 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_EU Corresponde à data no formato (d) d/ (M) M/ (yy) yy, (d) d- (M) M- (yy) yy ou (d) d. (M) M. (yy) yy. 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_FUSO HORÁRIO Corresponde ao deslocamento UTC 'Z' ou ao deslocamento de fuso horário com dois pontos opcionais no formato [+-] (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_SEGUNDO 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"}

TIMESTAMP _ 01 ISO86 Corresponde a ISO86 01 formato de data e hora (yy) yy- (M) M- (d) dT (H) H:mm: ((s) s) (Z| [+-] (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% {DATE_US} ou no formato da UE usando% {DATE_EU} 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"}

CARIMBO DE DATA Corresponde a% {DATE} seguido pelo padrão% {TIME}, 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_ 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_ RFC2822 Corresponde ao formato RFC2822 de data e hora: Dia, (d) d MonthName (yy) yy (H) H:mm :( s) s Z| [+-] (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_OUTRO 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_EVENTLOG Corresponde ao formato compacto de data e hora sem separadores: (yy) yymm (d) d (H) Hmm (s) s 20

Entrada: 20230515143000

Padrão: %{DATESTAMP_EVENTLOG:dateTime}

Saída: {"dateTime":"20230515143000"}

Padrões de grok longo

Padrão Grok Descrição Limite máximo de padrão Exemplo
NÍVEL DE REGISTRO Corresponde aos níveis de registro 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"}

DATA HTTP 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% {INT} grok 20

Entrada: 23/Nov/2024:14:30:00 +0640

Padrão: %{HTTPDATE:date}

Saída: {"date":"23/Nov/2024:14:30:00 +0640"}

CARIMBO DE DATA/HORA DO SYSLOG 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"}

PROGRESSIVO 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 PROG grok 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% {HOST} ou% {IP} 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"}

INSTALAÇÃO DE SYSLOG 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 comuns de troncos

Você pode usar padrões grok personalizados predefinidos para corresponder aos 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 exatamente um DADO. Padrão GREEDYDATA ou GREEDYDATA_MULTILINE.

Padrão grok Descrição Limite máximo de padrão

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:

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

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:

{ "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)

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

Analisar para OCSF

O processador ParseToOCSF converte registros no formato Open Cybersecurity Schema Framework (OCSF).

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

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

eventSource

O serviço ou processo que produz os eventos de log que serão convertidos com esse processador. Os valores válidos são os seguintes:

Sim

-

-

Versão OCSF

A versão do esquema OCSF a ser usada para os eventos de log transformados. Atualmente, o único valor suportado é V1.1

Sim

V1.1

-

Exemplo

O exemplo a seguir transforma os registros de fluxo da Amazon VPC para o formato OCSF.

[ "parseToOCSF": { eventSource: "VPCFlow", version: "V1.1" } ]

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 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 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 não suporta Amazon Route 53 Resolver registros.

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 da Amazon 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 é um tipo de processador de mutação de string que divide um campo em uma matriz usando um caractere delimitador.

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

entries

Matriz de entradas. Cada item na matriz deve conter source delimiter campos.

Sim

Máximo de entradas: 10

origem

A chave do valor do campo a ser dividido

Sim

Tamanho máximo: 128

delimitador

A string delimitadora na qual dividir o valor do campo

Sim

Tamanho máximo: 128

Exemplo 1

Veja o seguinte exemplo de evento de log:

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

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

Exemplo 2

O delimitador para dividir a string pode ter vários caracteres.

Veja o seguinte exemplo de evento de log:

{ "outer_key": { "inner_key": "item1, item2, item3" } }

A configuração do transformador é a seguinte:

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

O evento de registro transformado seria o seguinte.

{ "outer_key": { "inner_key": [ "item1", "item2", "item3" ] } }

Cadeia de caracteres substituta

O substituteString processador é um tipo de processador mutante de string que combina 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? Padrão Limites

entries

Matriz de entradas. Cada item na matriz deve conter to campos sourcefrom, e.

Sim

Máximo de entradas: 10

origem

A chave do campo a ser modificado

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 ou quando configurados a partir do. AWS Management Console Para obter mais informações, consulte Padrão de classe no site da Oracle.

Você pode agrupar um padrão (...) para criar um grupo de captura numerado e criar grupos de captura (?P<group_name>...) nomeados que possam ser referenciados no campo. to

Sim

Tamanho máximo: 128

com

A string a ser substituída por cada correspondência de from referências anteriores aos grupos de captura pode ser usada. Use o formulário $n para grupos numerados, como, $1 e use ${group_name} para grupos nomeados, como $. {my_group} >

Sim

Tamanho máximo: 128

Número máximo de referências anteriores: 10

Número máximo de referências anteriores duplicadas: 2

Exemplo 1

Veja o seguinte exemplo de evento de log:

{ "outer_key": { "inner_key1": "[]", "inner_key2": "123-345-567", "inner_key3": "A cat takes a catnap." } }

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" }, { "source": "outer_key.inner_key3", "from": "cat", "to": "dog" } ] } } ]

O evento de registro transformado seria o seguinte.

{ "outer_key": { "inner_key1": "value1", "inner_key2": "xxx-xxx-xxx", "inner_key3": "A dog takes a dognap." } }

Exemplo 2

Veja o seguinte exemplo de evento de log:

{ "outer_key": { "inner_key1": "Tom, Dick, and Harry", "inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession" } }

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

[ { "parseJSON": {} }, { "substituteString": { "entries": [ { "source": "outer_key.inner_key1", "from": "(\w+), (\w+), and (\w+)", "to": "$1 and $3" }, { "source": "outer_key.inner_key2", "from": "^arn:aws:sts::(?P<account_id>\\d{12}):assumed-role/(?P<role_name>[\\w+=,.@-]+)/(?P<role_session_name>[\\w+=,.@-]+)$", "to": "${account_id}:${role_name}:${role_session_name}" } ] } } ]

O evento de registro transformado seria o seguinte.

{ "outer_key": { "inner_key1": "Tom and Harry", "inner_key2": "123456789012:MyImportantRole:MySession" } }

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 conterkey,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 comotrue, o valor existente será substituído se key já existir no evento. O valor padrão é false. Não

false

Sem limite

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

Sem limite

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 contersource,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 comotrue, o valor existente será substituído se key já existir no evento. O valor padrão é false. Não

false

Sem limite

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 conterkey,target, e overwriteIfExists campos.

Sim

Sem limite

Máximo de entradas: 5

key

A chave para renomear

Sim

Sem limite

Tamanho máximo: 128

target

O novo nome da chave

Sim

Sem limite

Tamanho máximo: 128

Profundidade máxima de chave aninhada: 3

overwriteIfExists

Se você definir isso comotrue, o valor existente será substituído se key já existir no evento. O valor padrão é false. Não

false

Sem limite

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 contersource,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

Sem limite

Tamanho máximo: 128

Profundidade máxima de chave aninhada: 3

overwriteIfExists

Se você definir isso comotrue, o valor existente será substituído se key já existir no evento. O valor padrão é false. Não

false

Sem limite

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. flattenDefina como true para converter a matriz em um único valor com base no valor deflattenedElement.

Não

false

Elemento achatado

Se você flatten definir comotrue, use flattenedElement para especificar qual elemento, first oulast, 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 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

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