Processori configurabili di tipo parser Processori integrati per i AWS log venduti Processori di mutazione delle stringhe Processori JSON con mutazione Processori di conversione di tipi di dati

Processori che puoi usare

Questa sezione contiene informazioni su ciascun processore che è possibile utilizzare in un trasformatore di eventi di registro. I processori possono essere classificati in parser, mutatori di stringhe, mutatori JSON e processori di data.

Indice

Processori configurabili di tipo parser

parseJSON

Il processore ParseJSON analizza gli eventi di registro JSON e inserisce le coppie chiave-valore JSON estratte nella destinazione. Se non si specifica una destinazione, il processore posiziona la coppia chiave-valore sotto il nodo radice. Quando si utilizza parseJSON come primo processore, è necessario analizzare l'intero evento di registro utilizzandolo @message come campo di origine. Dopo l'analisi JSON iniziale, è possibile manipolare campi specifici nei processori successivi.

Il @message contenuto originale non viene modificato, le nuove chiavi vengono aggiunte al messaggio.

Campo Descrizione Obbligatorio? Predefinita Limiti

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
source	Percorso del campo nel registro dell'evento che verrà analizzato. Usa la notazione a punti per accedere ai campi secondari. Ad esempio, `store.book`	No	`@message`	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
destinazione	Il campo di destinazione del file JSON analizzato	No	`Parent JSON node`	Lunghezza massima: 128. Profondità massima della chiave annidata: 3

source

Percorso del campo nel registro dell'evento che verrà analizzato. Usa la notazione a punti per accedere ai campi secondari. Ad esempio, store.book

@message

Lunghezza massima: 128.

Profondità massima della chiave annidata: 3

destinazione

Il campo di destinazione del file JSON analizzato

Parent JSON node

Lunghezza massima: 128.

Profondità massima della chiave annidata: 3

Esempio

Supponiamo che un evento di registro importato abbia il seguente aspetto:


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

Quindi se abbiamo questo processore ParseJson:


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

L'evento di registro trasformato sarebbe il seguente.


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

grok

Usa il processore grok per analizzare e strutturare i dati non strutturati utilizzando il pattern matching. Questo processore può anche estrarre campi dai messaggi di registro.

Campo Descrizione Obbligatorio? Predefinita Limiti Note

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti	Note
source	Percorso del campo su cui applicare la corrispondenza Grok	No	`@message`	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
match	Il pattern grok da confrontare con l'evento log	Sì		Lunghezza massima: 512 Schemi di gruppo massimi: 20 Alcuni tipi di pattern grok hanno limiti di utilizzo individuali. Qualsiasi combinazione dei seguenti modelli può essere utilizzata fino a cinque volte: {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE} I pattern Grok non supportano le conversioni di tipo. Per i modelli di formato di log comuni (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG, SYSLOG5424), è supportato l'inclusione solo dei modelli DATA, GREEDYDATA o GREEDYDATA_MULTILINE dopo il modello di log comune.	Vedi tutti i pattern Grok supportati

source

Percorso del campo su cui applicare la corrispondenza Grok

@message

Lunghezza massima: 128.

Profondità massima della chiave annidata: 3

match

Il pattern grok da confrontare con l'evento log

Sì

Lunghezza massima: 512

Schemi di gruppo massimi: 20

Alcuni tipi di pattern grok hanno limiti di utilizzo individuali. Qualsiasi combinazione dei seguenti modelli può essere utilizzata fino a cinque volte: {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE}

I pattern Grok non supportano le conversioni di tipo.

Per i modelli di formato di log comuni (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG, SYSLOG5424), è supportato l'inclusione solo dei modelli DATA, GREEDYDATA o GREEDYDATA_MULTILINE dopo il modello di log comune.

Vedi tutti i pattern Grok supportati

Struttura di un pattern Grok

Questa è la struttura del pattern grok supportata:


%{PATTERN_NAME:FIELD_NAME}

PATTERN_NAME: si riferisce a un'espressione regolare predefinita per la corrispondenza di un tipo specifico di dati. Sono supportati solo i modelli grok predefiniti dall'elenco dei modelli grok supportati. La creazione di modelli personalizzati non è consentita.
FIELD_NAME: assegna un nome al valore estratto. FIELD_NAMEè facoltativo, ma se non si specifica questo valore, i dati estratti verranno eliminati dall'evento di registro trasformato. Se FIELD_NAME utilizza la notazione punteggiata (ad esempio, «parent.child»), viene considerata un percorso JSON.
Conversione dei tipi: le conversioni di tipo esplicite non sono supportate. Usa il TypeConverter processore per convertire il tipo di dati di qualsiasi valore estratto da grok.

Per creare espressioni di corrispondenza più complesse, puoi combinare diversi modelli grok. È possibile combinare fino a 20 pattern grok per abbinare un evento log. Ad esempio, questa combinazione di pattern %{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data} può essere utilizzata per estrarre campi da una voce di slow log di Redis come questa:

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

Esempi di Grok

Esempio 1: Usa grok per estrarre un campo da log non strutturati

Registro di esempio:


293750 server-01.internal-network.local OK "[Thread-000] token generated"

Trasformatore utilizzato:


[
     {
         "grok": {
             "match": "%{NUMBER:version} %{HOSTNAME:hostname} %{NOTSPACE:status} %{QUOTEDSTRING:logMsg}"
         }
    }
]

Output:


{
  "version": "293750",
  "hostname": "server-01.internal-network.local",
  "status": "OK",
  "logMsg": "[Thread-000] token generated"
}

Registro di esempio:


23/Nov/2024:10:25:15 -0900 172.16.0.1 200

Trasformatore utilizzato:


[
    {
        "grok": {
            "match": "%{HTTPDATE:timestamp} %{IPORHOST:clientip} %{NUMBER:response_status}"
        }
    }
]

Output:


{
  "timestamp": "23/Nov/2024:10:25:15 -0900",
  "clientip": "172.16.0.1",
  "response_status": "200"
}

Esempio 2: usa grok in combinazione con parseJSON per estrarre campi da un evento di registro JSON

Registro di esempio:


{
    "timestamp": "2024-11-23T16:03:12Z",
    "level": "ERROR",
    "logMsg": "GET /page.html HTTP/1.1"
}

Trasformatore utilizzato:


[
     {
        "parseJSON": {}
    },
    {
         "grok": {
            "source": "logMsg",
             "match": "%{WORD:http_method} %{NOTSPACE:request} HTTP/%{NUMBER:http_version}"
         }
    }
]

Output:


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

Esempio 3: pattern Grok con annotazione punteggiata in FIELD_NAME

Registro di esempio:


192.168.1.1 GET /index.html?param=value 200 1234

Trasformatore utilizzato:


[
    {
        "grok": {
            "match": "%{IP:client.ip} %{WORD:method} %{URIPATHPARAM:request.uri} %{NUMBER:response.status} %{NUMBER:response.bytes}"
        }
    }
]

Output:


{
  "client": {
    "ip": "192.168.1.1"
  },
  "method": "GET",
  "request": {
    "uri": "/index.html?param=value"
  },
  "response": {
    "status": "200",
    "bytes": "1234"
  }
}

Schemi grok supportati

Le tabelle seguenti elencano i modelli supportati dal grok processore.

Schemi di gruppo generali

Modello Grok	Descrizione	Limite massimo del pattern	Esempio
USERNAME o USER	Corrisponde a uno o più caratteri che possono includere lettere minuscole (a-z), lettere maiuscole (A-Z), cifre (0-9), punti (.), caratteri di sottolineatura (_) o trattini (-)	20	Input: `user123.name-TEST` Modello: `%{USERNAME:name}` Uscita: `{"name": "user123.name-TEST"}`
INT	Corrisponde a un segno più o meno opzionale seguito da una o più cifre.	20	Ingresso: `-456` Modello: `%{INT:num}` Uscita: `{"num": "-456"}`
BASE10 NUM	Corrisponde a un numero intero o a virgola mobile con segno e virgola decimale opzionali	20	Ingresso: `-0.67` Modello: `%{BASE10NUM:num}` Uscita: `{"num": "-0.67"}`
BASE16NUM	Corrisponde ai numeri decimali ed esadecimali con un segno opzionale (+ o -) e un prefisso 0x opzionale	20	Ingresso: `+0xA1B2` Modello: `%{BASE16NUM:num}` Uscita: `{"num": "+0xA1B2"}`
PUNTO	Corrisponde a numeri interi positivi senza zeri iniziali, costituiti da una o più cifre (1-9 seguito da 0-9)	20	Ingresso: `123` Modello: `%{POSINT:num}` Uscita: `{"num": "123"}`
NONNEGINT	Corrisponde a qualsiasi numero intero (composto da una o più cifre da 0 a 9) compresi zero e numeri con zeri iniziali.	20	Ingresso: `007` Modello: `%{NONNEGINT:num}` Uscita: `{"num": "007"}`
PAROLA	Corrisponde a parole intere composte da uno o più caratteri di parola (\ w), incluse lettere, cifre e caratteri di sottolineatura	20	Ingresso: `user_123` Modello: `%{WORD:user}` Uscita: `{"user": "user_123"}`
NON SPAZIO	Corrisponde a uno o più caratteri diversi dagli spazi bianchi.	5	Ingresso: `hello_world123` Modello: `%{NOTSPACE:msg}` Uscita: `{"msg": "hello_world123"}`
SPACE	Corrisponde a zero o più caratteri di spazio bianco.	5	Ingresso: `" "` Modello: `%{SPACE:extra}` Uscita: `{"extra": " "}`
DATA	Corrisponde a qualsiasi carattere (eccetto la nuova riga) zero o più volte, non è avido.	5	Ingresso: `abc def ghi` Modello: `%{DATA:x} %{DATA:y}` Uscita: `{"x": "abc", "y": "def ghi"}`
DATI AVIDI	Corrisponde a qualsiasi carattere (eccetto la nuova riga) zero o più volte, greedy.	5	Ingresso: `abc def ghi` Modello: `%{GREEDYDATA:x} %{GREEDYDATA:y}` Uscita: `{"x": "abc def", "y": "ghi"}`
GREEDYDATA_MULTILINE	Corrisponde a qualsiasi carattere (inclusa la nuova riga) zero o più volte, greedy.	1	Input: `abc` `def` `ghi` Modello: `%{GREEDYDATA_MULTILINE:data}` Uscita: `{"data": "abc\ndef\nghi"}`
STRINGA TRA VIRGOLETTE	Corrisponde alle stringhe tra virgolette (virgolette singole o doppie) ai caratteri con escape.	20	Ingresso: `"Hello, world!"` Modello: `%{QUOTEDSTRING:msg}` Uscita: `{"msg": "Hello, world!"}`
UUID	Corrisponde a un formato UUID standard: 8 caratteri esadecimali, seguiti da tre gruppi di 4 caratteri esadecimali e termina con 12 caratteri esadecimali, tutti separati da trattini.	20	Ingresso: `550e8400-e29b-41d4-a716-446655440000` Modello: `%{UUID:id}` Uscita: `{"id": "550e8400-e29b-41d4-a716-446655440000"}`
URNA	Corrisponde alla sintassi URN (Uniform Resource Name).	20	Ingresso: `urn:isbn:0451450523` Modello: `%{URN:urn}` Uscita: `{"urn": "urn:isbn:0451450523"}`

AWS modelli grok

Pattern Descrizione Limite massimo del modello Esempio

Pattern	Descrizione	Limite massimo del modello	Esempio
ARN	Corrisponde AWS ad Amazon Resource Names (ARNs), acquisendo la partizione (`aws`,, or`aws-us-gov`)`aws-cn`, il servizio, la regione, l'ID account e fino a 5 identificatori gerarchici di risorse separati da barre. Non ARNs corrisponderà alle informazioni mancanti tra i due punti.	5	Ingresso: `arn:aws:iam:us-east-1:123456789012:user/johndoe` Modello: `%{ARN:arn}` Uscita: `{"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}`

ARN

Corrisponde AWS ad Amazon Resource Names (ARNs), acquisendo la partizione (aws,, oraws-us-gov)aws-cn, il servizio, la regione, l'ID account e fino a 5 identificatori gerarchici di risorse separati da barre. Non ARNs corrisponderà alle informazioni mancanti tra i due punti.

Ingresso: arn:aws:iam:us-east-1:123456789012:user/johndoe

Modello: %{ARN:arn}

Uscita: {"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}

Schemi di gruppo di rete

Modello Grok	Descrizione	Limite massimo del pattern	Esempio
CISCOMAC	Corrisponde a un indirizzo MAC in formato esadecimale 4-4-4.	20	Ingresso: `0123.4567.89AB` Modello: `%{CISCOMAC:MacAddress}` Uscita: `{"MacAddress": "0123.4567.89AB"}`
WINDOWS MAC	Corrisponde a un indirizzo MAC in formato esadecimale con trattini	20	Ingresso: `01-23-45-67-89-AB` Modello: `%{WINDOWSMAC:MacAddress}` Uscita: `{"MacAddress": "01-23-45-67-89-AB"}`
MAC COMUNE	Corrisponde a un indirizzo MAC in formato esadecimale con due punti.	20	Ingresso: `01:23:45:67:89:AB` Modello: `%{COMMONMAC:MacAddress}` Uscita: `{"MacAddress": "01:23:45:67:89:AB"}`
MAC	Corrisponde a uno dei pattern grok CISCOMAC, WINDOWSMAC o COMMONMAC	20	Ingresso: `01:23:45:67:89:AB` Modello: `%{MAC:m1}` Uscita: `{"m1":"01:23:45:67:89:AB"}`
IPV6	Corrisponde IPv6 agli indirizzi, inclusi i moduli compressi e gli indirizzi IPv4 mappati IPv6 .	5	Ingresso: `2001:db8:3333:4444:5555:6666:7777:8888` Modello: `%{IPV6:ip}` Uscita: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`
IPV4	Corrisponde a un IPv4 indirizzo.	20	Ingresso: `192.168.0.1` Modello: `%{IPV4:ip}` Uscita: `{"ip": "192.168.0.1"}`
IP	IPv6 Corrisponde agli indirizzi supportati da% {IPv6} o IPv4 agli indirizzi supportati da% {IPv4}	5	Ingresso: `192.168.0.1` Modello: `%{IP:ip}` Uscita: `{"ip": "192.168.0.1"}`
HOSTNAME o HOST	Corrisponde ai nomi di dominio, inclusi i sottodomini	5	Ingresso: `server-01.internal-network.local` Modello: `%{HOST:host}` Uscita: `{"host": "server-01.internal-network.local"}`
IP O HOST	Corrisponde a un nome host o a un indirizzo IP	5	Ingresso: `2001:db8:3333:4444:5555:6666:7777:8888` Modello: `%{IPORHOST:ip}` Uscita: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`
HOSTPORT	Corrisponde a un indirizzo IP o a un nome host come supportato dal pattern% {IPORHOST} seguito da due punti e da un numero di porta, che nell'output registra la porta come «PORT».	5	Ingresso: `192.168.1.1:8080` Modello: `%{HOSTPORT:ip}` Uscita: `{"ip":"192.168.1.1:8080","PORT":"8080"}`
URIHOST	Corrisponde a un indirizzo IP o a un nome host, come supportato dal pattern% {IPORHOST}, seguito facoltativamente da due punti e da un numero di porta, identificando la porta come «porta», se presente.	5	Ingresso: `example.com:443 10.0.0.1` Modello: `%{URIHOST:host} %{URIHOST:ip}` Uscita: `{"host":"example.com:443","port":"443","ip":"10.0.0.1"}`

Path Grok pattern

Modello Grok	Descrizione	Limite massimo del pattern	Esempio
UNIXPATH	Corrisponde ai percorsi degli URL, inclusi potenzialmente i parametri di query.	20	Ingresso: `/search?q=regex` Modello: `%{UNIXPATH:path}` Uscita: `{"path":"/search?q=regex"}`
PERCORSO VINCENTE	Corrisponde ai percorsi dei file di Windows.	5	Ingresso: `C:\Users\John\Documents\file.txt` Modello: `%{WINPATH:path}` Uscita: `{"path": "C:\\Users\\John\\Documents\\file.txt"}`
PATH	Corrisponde ai percorsi dei file URL o Windows	5	Ingresso: `/search?q=regex` Modello: `%{PATH:path}` Uscita: `{"path":"/search?q=regex"}`
TTY	Corrisponde ai percorsi dei dispositivi Unix per terminali e pseudo-terminali.	20	Ingresso: `/dev/tty1` Modello: `%{TTY:path}` Uscita: `{"path":"/dev/tty1"}`
URIPROTO	Corrisponde alle lettere, seguite facoltativamente da un carattere più (+) e lettere aggiuntive o caratteri più (+)	20	Ingresso: `web+transformer` Modello: `%{URIPROTO:protocol}` Uscita: `{"protocol":"web+transformer"}`
URIPATA	Corrisponde al componente del percorso di un URI	20	Ingresso: `/category/sub-category/product_name` Modello: `%{URIPATH:path}` Uscita: `{"path":"/category/sub-category/product_name"}`
URIPARAM	Corrisponde ai parametri della query URL	5	Ingresso: `?param1=value1&param2=value2` Modello: `%{URIPARAM:url}` Uscita: `{"url":"?param1=value1&param2=value2"}`
PARAMETRO URIPATH	Corrisponde a un percorso URI seguito facoltativamente da parametri di query	5	Ingresso: `/category/sub-category/product?id=12345&color=red` Modello: `%{URIPATHPARAM:path}` Uscita: `{"path":"/category/sub-category/product?id=12345&color=red"}`
URI	Corrisponde a un URI completo	5	Ingresso: `https://user:password@example.com/path/to/resource?param1=value1&param2=value2` Modello: `%{URI:uri}` Uscita: `{"path":"https://user:password@example.com/path/to/resource?param1=value1&param2=value2"}`

Schemi grok di data e ora

Modello Grok	Descrizione	Limite massimo del pattern	Esempio
MESE	Corrisponde ai nomi completi o abbreviati dei mesi inglesi a parole intere	20	Ingresso: `Jan` Modello: `%{MONTH:month}` Uscita: `{"month":"Jan"}` Ingresso: `January` Modello: `%{MONTH:month}` Uscita: `{"month":"January"}`
NUMERO DI MESI	Corrisponde ai numeri dei mesi da 1 a 12, con lo zero iniziale opzionale per i mesi a una cifra.	20	Ingresso: `5` Modello: `%{MONTHNUM:month}` Uscita: `{"month":"5"}` Ingresso: `05` Modello: `%{MONTHNUM:month}` Uscita: `{"month":"05"}`
MONTHNUM2	Corrisponde ai numeri dei mesi a due cifre compresi tra 01 e 12.	20	Ingresso: `05` Modello: `%{MONTHNUM2:month}` Uscita: `{"month":"05"}`
MESE/GIORNO	Corrisponde al giorno del mese compreso tra 1 e 31, con zero iniziale opzionale.	20	Ingresso: `31` Modello: `%{MONTHDAY:monthDay}` Uscita: `{"monthDay":"31"}`
ANNO	Corrisponde all'anno in due o quattro cifre	20	Ingresso: `2024` Modello: `%{YEAR:year}` Uscita: `{"year":"2024"}` Ingresso: `24` Modello: `%{YEAR:year}` Uscita: `{"year":"24"}`
GIORNO	Corrisponde ai nomi dei giorni completi o abbreviati.	20	Ingresso: `Tuesday` Modello: `%{DAY:day}` Uscita: `{"day":"Tuesday"}`
ORA	Corrisponde all'ora nel formato a 24 ore con uno zero iniziale opzionale (0) 0-23.	20	Ingresso: `22` Modello: `%{HOUR:hour}` Uscita: `{"hour":"22"}`
MINUTO	Corrisponde ai minuti (00-59).	20	Ingresso: `59` Modello: `%{MINUTE:min}` Uscita: `{"min":"59"}`
SECOND	Corrisponde a un numero che rappresenta i secondi (0) 0-60, seguito facoltativamente da un punto decimale o due punti e da una o più cifre per i minuti frazionari	20	Ingresso: `3` Modello: `%{SECOND:second}` Uscita: `{"second":"3"}` Ingresso: `30.5` Modello: `%{SECOND:minSec}` Uscita: `{"minSec":"30.5"}` Ingresso: `30:5` Modello: `%{SECOND:minSec}` Uscita: `{"minSec":"30:5"}`
TIME	Corrisponde a un formato orario con ore, minuti e secondi nel formato (H) H:mm :( s) s. I secondi includono il secondo intercalare (0) 0-60.	20	Ingresso: `09:45:32` Modello: `%{TIME:time}` Uscita: `{"time":"09:45:32"}`
DATA_US	Corrisponde a una data nel formato (M) M/ (d) d/ (yy) yy o (M) M- (d) d- (yy) yy.	20	Ingresso: `11/23/2024` Modello: `%{DATE_US:date}` Uscita: `{"date":"11/23/2024"}` Ingresso: `1-01-24` Modello: `%{DATE_US:date}` Uscita: `{"date":"1-01-24"}`
DATE_EU	Corrisponde alla data nel formato (d) d/ (M) M/ (yy) yy, (d) d- (M) M- (yy) yy o (d) d. (M) M. (yy) yy.	20	Ingresso: `23/11/2024` Modello: `%{DATE_EU:date}` Uscita: `{"date":"23/11/2024"}` Ingresso: `1.01.24` Modello: `%{DATE_EU:date}` Uscita: `{"date":"1.01.24"}`
ISO8601_FUSO ORARIO	Corrisponde all'offset UTC 'Z' o all'offset del fuso orario con due punti opzionali nel formato [+-] (H) H (:) mm.	20	Ingresso: `+05:30` Modello: `%{ISO8601_TIMEZONE:tz}` Uscita: `{"tz":"+05:30"}` Ingresso: `-530` Modello: `%{ISO8601_TIMEZONE:tz}` Uscita: `{"tz":"-530"}` Ingresso: `Z` Modello: `%{ISO8601_TIMEZONE:tz}` Uscita: `{"tz":"Z"}`
ISO8601_SECONDI	Corrisponde a un numero che rappresenta i secondi (0) 0-60, seguito facoltativamente da un punto decimale o due punti e da una o più cifre per frazioni di secondo	20	Ingresso: `60` Modello: `%{ISO8601_SECOND:second}` Uscita: `{"second":"60"}`
TIMESTAMP_ 01 ISO86	Corrisponde al formato ISO86 01 datetime (yy) yy- (M) M- (d) dT (H) H:mm :( (s) s) (Z\| [+-] (H) H:mm) con secondi e fuso orario opzionali.	20	Ingresso: `2023-05-15T14:30:00+05:30` Modello: `%{TIMESTAMP_ISO8601:timestamp}` Uscita: `{"timestamp":"2023-05-15T14:30:00+05:30"}` Ingresso: `23-5-1T1:25+5:30` Modello: `%{TIMESTAMP_ISO8601:timestamp}` Uscita: `{"timestamp":"23-5-1T1:25+5:30"}` Ingresso: `23-5-1T1:25Z` Modello: `%{TIMESTAMP_ISO8601:timestamp}` Uscita: `{"timestamp":"23-5-1T1:25Z"}`
DATE	Corrisponde a una data nel formato USA utilizzando% {DATE_US} o nel formato UE utilizzando% {DATE_EU}	20	Ingresso: `11/29/2024` Modello: `%{DATE:date}` Uscita: `{"date":"11/29/2024"}` Ingresso: `29.11.2024` Modello: `%{DATE:date}` Uscita: `{"date":"29.11.2024"}`
TIMBRO DATARIO	Corrisponde a% {DATE} seguito dallo schema% {TIME}, separato da uno spazio o da un trattino.	20	Ingresso: `29-11-2024 14:30:00` Modello: `%{DATESTAMP:dateTime}` Uscita: `{"dateTime":"29-11-2024 14:30:00"}`
TZ	Corrisponde alle abbreviazioni dei fusi orari comuni (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC).	20	Ingresso: `PDT` Modello: `%{TZ:tz}` Uscita: `{"tz":"PDT"}`
TIMBRO DATA_ RFC822	Corrisponde a data e ora nel formato: Day MonthName (D) D (YY) YY (H) H:mm :( s) s Timezone	20	Ingresso: `Monday Jan 5 23 1:30:00 CDT` Modello: `%{DATESTAMP_RFC822:dateTime}` Uscita: `{"dateTime":"Monday Jan 5 23 1:30:00 CDT"}` Ingresso: `Mon January 15 2023 14:30:00 PST` Modello: `%{DATESTAMP_RFC822:dateTime}` Uscita: `{"dateTime":"Mon January 15 2023 14:30:00 PST"}`
TIMBRO DATA_ RFC2822	Corrisponde al formato RFC2822 data-ora: Day, (d) d (yy) yy MonthName (H) H:mm :( s) s Z\| [+-] (H) H:mm	20	Ingresso: `Mon, 15 May 2023 14:30:00 +0530` Modello: `%{DATESTAMP_RFC2822:dateTime}` Uscita: `{"dateTime":"Mon, 15 May 2023 14:30:00 +0530"}` Ingresso: `Monday, 15 Jan 23 14:30:00 Z` Modello: `%{DATESTAMP_RFC2822:dateTime}` Uscita: `{"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}`
DATESTAMP_OTHER	Corrisponde a data e ora nel formato: Giorno MonthName (d) d (H) H:mm :( s) s Fuso orario (yy) yy	20	Ingresso: `Mon May 15 14:30:00 PST 2023` Modello: `%{DATESTAMP_OTHER:dateTime}` Uscita: `{"dateTime":"Mon May 15 14:30:00 PST 2023"}`
DATESTAMP_EVENTLOG	Corrisponde al formato datetime compatto senza separatori: (yy) yYmm (d) d (H) Hmm (s) s	20	Ingresso: `20230515143000` Modello: `%{DATESTAMP_EVENTLOG:dateTime}` Uscita: `{"dateTime":"20230515143000"}`

Schemi di gruppo logaritmici

Modello Grok	Descrizione	Limite massimo del pattern	Esempio
LIVELLO DI REGISTRO	Corrisponde ai livelli di log standard in diverse lettere maiuscole e abbreviazioni, tra cui:`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	Ingresso: `INFO` Modello: `%{LOGLEVEL:logLevel}` Uscita: `{"logLevel":"INFO"}`
HTTP: DATA	Corrisponde al formato di data e ora spesso utilizzato nei file di registro. Formato: (d) d/MonthName/(yy) yy :( H) H:mm :( s) s Fuso orario: corrisponde ai nomi completi o abbreviati dei mesi in inglese (esempio MonthName: «Jan» o «January») Fuso orario: corrisponde al modello% {INT} grok	20	Ingresso: `23/Nov/2024:14:30:00 +0640` Modello: `%{HTTPDATE:date}` Uscita: `{"date":"23/Nov/2024:14:30:00 +0640"}`
TIMESTAMP SYSLOG	Corrisponde al formato della data con MonthName (d) d (H) H:mm :( s) s: corrisponde ai nomi completi o abbreviati dei mesi in inglese (esempio MonthName: «Jan» o «January»)	20	Ingresso: `Nov 29 14:30:00` Modello: `%{SYSLOGTIMESTAMP:dateTime}` Uscita: `{"dateTime":"Nov 29 14:30:00"}`
PROG	Corrisponde al nome di un programma composto da una stringa di lettere, cifre, punti, trattini bassi, barra, segno di percentuale e trattini.	20	Ingresso: `user.profile/settings-page` Modello: `%{PROG:program}` Uscita: `{"program":"user.profile/settings-page"}`
SYSLOGPROG	Corrisponde al pattern PROG grok seguito facoltativamente da un ID di processo tra parentesi quadre.	20	Ingresso: `user.profile/settings-page[1234]` Modello: `%{SYSLOGPROG:programWithId}` Uscita: `{"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}`
SYSLOGHOST	Corrisponde a uno schema% {HOST} o% {IP}	5	Ingresso: `2001:db8:3333:4444:5555:6666:7777:8888` Modello: `%{SYSLOGHOST:ip}` Uscita: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`
IMPIANTO SYSLOG	Corrisponde alla priorità syslog in formato decimale. Il valore deve essere racchiuso tra parentesi angolari (<>).	20	Ingresso: `<13.6>` Modello: `%{SYSLOGFACILITY:syslog}` Uscita: `{"syslog":"<13.6>","facility":"13","priority":"6"}`

Schemi di log grok comuni

È possibile utilizzare modelli grok personalizzati predefiniti per abbinare i formati di registro Apache, NGINX e Syslog Protocol (RFC 5424). Quando si utilizzano questi modelli specifici, devono essere i primi modelli nella configurazione corrispondente e nessun altro modello può precederli. Inoltre, puoi seguirli solo con esattamente un DATO. Pattern GREEDYDATA o GREEDYDATA_MULTILINE.

Pattern grok	Descrizione	Limite massimo del modello
APACHE_ACCESS_LOG	Corrisponde ai log di accesso di Apache	1
NGINX_ACCESS_LOG	Corrisponde ai log di accesso di NGINX	1
SYSLOG5424	Corrisponde ai log del protocollo Syslog (RFC 5424)	1

Di seguito sono riportati esempi validi e non validi per l'utilizzo di questi modelli di formato di registro comuni.


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

Esempi di formati di log comuni

Esempio di log di Apache

Registro di esempio:


127.0.0.1 - - [03/Aug/2023:12:34:56 +0000] "GET /page.html HTTP/1.1" 200 1234

Trasformatore:


[
     {
        "grok": {
            "match": "%{APACHE_ACCESS_LOG}"
        }
    }
]

Output:


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

Esempio di log NGINX

Registro di esempio:


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"

Trasformatore:


[
     {
        "grok": {
            "match": "%{NGINX_ACCESS_LOG}"
        }
    }
]

Output:


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

Esempio di log del protocollo Syslog (RFC 5424)

Registro di esempio:


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

Trasformatore:


[
     {
        "grok": {
            "match": "%{SYSLOG5424}"
        }
    }
]

Output:


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

Analizza in OCSF

Il processore ParseToOCSF converte i log in formato Open Cybersecurity Schema Framework (OCSF).

Il @message contenuto originale non viene modificato, le nuove chiavi vengono aggiunte al messaggio.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
eventSource	Il servizio o il processo che produce gli eventi di registro che verranno convertiti con questo processore. I valori validi sono i seguenti. `CloudTrail`per CloudTrail registrare eventi di gestione, eventi relativi ai dati Lambda o eventi dati CloudTrail in Amazon S3. CloudTrail `Route53Resolver`per i log delle interrogazioni di Route 53 Resolver. `VPCFlow`per i log di flusso di Amazon VPC. `EKSAudit`per i log di controllo di Amazon EKS. `AWSWAF`per i AWS WAF log.	Sì	-	-
versione OCSF	La versione dello schema OCSF da utilizzare per gli eventi di registro trasformati. Attualmente, l'unico valore supportato è `V1.1`	Sì	`V1.1`	-

Esempio

L'esempio seguente trasforma i log di flusso di Amazon VPC in formato OCSF.


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

csv

Il processore csv analizza i valori separati da virgole (CSV) dagli eventi di registro in colonne.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
source	Percorso del campo nell'evento di registro che verrà analizzato	No	`@message`	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
delimitatore	Il carattere utilizzato per separare ogni colonna nell'evento di registro dei valori separati da virgole originale	No	`,`	Lunghezza massima: 1
Cita carattere	Carattere utilizzato come qualificatore di testo per una singola colonna di dati	No	`"`	Lunghezza massima: 1
columns	Elenco di nomi da utilizzare per le colonne dell'evento di registro trasformato.	No	`[column_1, column_2 ...]`	Numero massimo di colonne CSV: 100 Lunghezza massima: 128. Profondità massima della chiave annidata: 3

Esempio

Supponiamo che parte di un evento di registro importato abbia il seguente aspetto:


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

Supponiamo di utilizzare solo il processore csv:


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

L'evento di registro trasformato sarebbe il seguente.


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

parseKeyValue

Utilizzate il parseKeyValueprocessore per analizzare un campo specificato in coppie chiave-valore. È possibile personalizzare il processore per analizzare le informazioni sui campi con le seguenti opzioni.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
source	Percorso del campo nel registro dell'evento che verrà analizzato	No	`@message`	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
destinazione	Il campo di destinazione in cui inserire le coppie chiave-valore estratte	No		Lunghezza massima: 128.
FieldDelimiter	La stringa delimitatrice di campo utilizzata tra coppie chiave-valore negli eventi del registro originale	No	`&`	Lunghezza massima: 128.
keyValueDelimiter	La stringa delimitatrice da utilizzare tra la chiave e il valore in ogni coppia nell'evento di registro trasformato	No	`=`	Lunghezza massima: 128.
nonMatchValue	Un valore da inserire nel campo del valore del risultato, quando una coppia chiave-valore non viene divisa correttamente.	No		Lunghezza massima: 128.
keyPrefix	Se vuoi aggiungere un prefisso a tutte le chiavi trasformate, specificalo qui.	No		Lunghezza massima: 128.
overwriteIfExists	Se sovrascrivere il valore se la chiave di destinazione esiste già	No	`false`

Esempio

Prendiamo il seguente esempio di evento di registro:


key1:value1!key2:value2!key3:value3!key4

Supponiamo di utilizzare la seguente configurazione del processore:


[
    {
        "parseKeyValue": {
            "destination": "new_key",
            "fieldDelimiter": "!",
            "keyValueDelimiter": ":",
            "nonMatchValue": "defaultValue",
            "keyPrefix": "parsed_"
        }
    }
]

L'evento di registro trasformato sarebbe il seguente.


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

Processori integrati per i AWS log venduti

Analizza WAF

Usa questo processore per analizzare i log AWS WAF venduti, prende il contenuto httpRequest.headers e crea chiavi JSON da ogni nome di intestazione, con il valore corrispondente. Fa lo stesso anche per. labels Queste trasformazioni possono rendere molto più semplice l'interrogazione dei AWS WAF log. Per ulteriori informazioni sul formato dei AWS WAF log, consulta Esempi di log per il traffico ACL web.

Questo processore accetta solo @message come input.

Importante

Se si utilizza questo processore, deve essere il primo processore del trasformatore.

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del processore è la seguente:


[
    {
        "parseWAF": {}
    }
]

L'evento di registro trasformato sarebbe il seguente.


{
  "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": []
}

parsePostGres

Usa questo processore per analizzare i log Amazon RDS for PostgreSQL forniti, estrarre campi e convertirli in formato JSON. Per ulteriori informazioni sul formato di registro RDS for PostgreSQL, consulta File di log del database RDS for PostgreSQL.

Questo processore accetta solo come input. @message

Importante

Se si utilizza questo processore, deve essere il primo processore del trasformatore.

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del processore è la seguente:


[
    {
        "parsePostgres": {}
    }
]

L'evento di registro trasformato sarebbe il seguente.


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

parseCloudFront

Usa questo processore per analizzare i log Amazon CloudFront forniti, estrarre campi e convertirli in formato JSON. I valori dei campi codificati vengono decodificati. I valori interi e doppi vengono trattati come tali. Per ulteriori informazioni sul formato dei Amazon CloudFront log, consulta Configurare e utilizzare i log standard (log di accesso).

Questo processore accetta solo @message come input.

Importante

Se si utilizza questo processore, deve essere il primo processore del trasformatore.

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del processore è la seguente:


[
    {
        "parseCloudfront": {}
    }
]

L'evento di registro trasformato sarebbe il seguente.


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

parseRoute53

Usa questo processore per analizzare i log Amazon Route 53 Public Data Plane forniti, estrarre campi e convertirli in formato JSON. I valori dei campi codificati vengono decodificati. Questo processore non supporta Amazon Route 53 Resolver i log.

Questo processore accetta solo @message come input.

Importante

Se si utilizza questo processore, deve essere il primo processore del trasformatore.

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del processore è la seguente:


[
    {
        "parseRoute53": {}
    }
]

L'evento di registro trasformato sarebbe il seguente.


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

ParseVPC

Usa questo processore per analizzare i log venduti da Amazon VPC, estrarre campi e convertirli in formato JSON. I valori dei campi codificati vengono decodificati.

Questo processore accetta solo @message come input.

Importante

Se si utilizza questo processore, deve essere il primo processore del trasformatore.

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del processore è la seguente:


[
    {
        "parseVPC": {}
    }
]

L'evento di registro trasformato sarebbe il seguente.


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

Processori di mutazione delle stringhe

lowerCaseString

Il lowerCaseString processore converte una stringa nella sua versione minuscola.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
Con chiavi	Un elenco di chiavi da convertire in lettere minuscole	Sì		Numero massimo di voci: 10

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata lowerCaseString conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

upperCaseString

Il upperCaseString processore converte una stringa nella sua versione maiuscola.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
Con chiavi	Un elenco di chiavi da convertire in lettere maiuscole	Sì		Numero massimo di voci: 10

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata upperCaseString conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

SplitString

Il splitString processore è un tipo di processore di mutazione di stringhe che divide un campo in un array utilizzando un carattere delimitante.

Campo	Descrizione	Obbligatorio?	Limiti
voci	Matrice di voci. Ogni elemento dell'array deve contenere `source` `delimiter` campi.	Sì	Numero massimo di iscrizioni: 10
source	La chiave del valore del campo da dividere	Sì	Lunghezza massima: 128.
delimitatore	La stringa delimitatrice su cui dividere il valore del campo	Sì	Lunghezza massima: 128.

Esempio 1

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata splitString conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

Esempio 2

Il delimitatore su cui dividere la stringa può contenere più caratteri.

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è la seguente:


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

L'evento di registro trasformato sarebbe il seguente.


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

Stringa sostitutiva

Il substituteString processore è un tipo di processore di modifica delle stringhe che abbina il valore di una chiave a un'espressione regolare e sostituisce tutte le corrispondenze con una stringa sostitutiva.

Campo	Descrizione	Obbligatorio?	Limiti
voci	Matrice di voci. Ogni elemento dell'array deve contenere `source` `to` campi e. `from`	Sì	Numero massimo di iscrizioni: 10
source	La chiave del campo da modificare	Sì	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
from	La stringa di espressioni regolari da sostituire. I caratteri regex speciali come [e] devono essere evitati usando\\ quando si usano le virgolette doppie e con\ quando si usano le virgolette singole o quando sono configurati da. AWS Management Console Per ulteriori informazioni, vedere Class Pattern sul sito Web di Oracle. È possibile inserire un pattern `(...)` per creare un gruppo di acquisizione numerato e creare gruppi di acquisizione `(?P<group_name>...)` denominati a cui è possibile fare riferimento nel campo. `to`	Sì	Lunghezza massima: 128.
in	È possibile utilizzare la stringa da sostituire per ogni corrispondenza di Backreference ai gruppi di `from` acquisizione. Usa il modulo $n per gruppi numerati come `$1` e `${group_name}` usalo per gruppi denominati come $. `{my_group}` >	Sì	Lunghezza massima: 128. Numero massimo di riferimenti retrospettivi: 10 Numero massimo di riferimenti retrospettivi duplicati: 2

Esempio 1

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata substituteString conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

Esempio 2

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata substituteString conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

TrimString

Il trimString processore rimuove gli spazi bianchi dall'inizio e dalla fine di una chiave.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
Con chiavi	Un elenco di tasti da tagliare	Sì		Numero massimo di iscrizioni: 10

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata trimString conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

Processori JSON con mutazione

Aggiungi chiavi

Utilizzate il addKeys processore per aggiungere nuove coppie chiave-valore all'evento di registro.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
voci	Matrice di voci. Ogni elemento dell'array può contenere `key` `overwriteIfExists` campi e. `value`	Sì		Numero massimo di iscrizioni: 5
Chiave	La chiave della nuova voce da aggiungere	Sì		Lunghezza massima: 128. Profondità massima della chiave annidata: 3
value	Il valore della nuova voce da aggiungere	Sì		Lunghezza massima: 256
overwriteIfExists	Se lo imposti su`true`, il valore esistente viene sovrascritto se `key` già presente nell'evento. Il valore predefinito è `false`.	No	false	Nessun limite

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata addKeys conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

DeleteKeys

Usa il deleteKeys processore per eliminare i campi da un evento di registro. Questi campi possono includere coppie chiave-valore.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
Con chiavi	L'elenco delle chiavi da eliminare.	Sì	Nessun limite	Numero massimo di iscrizioni: 5

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata deleteKeys conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


{
  "outer_key": {}
}

moveKeys

Usa il moveKeys processore per spostare una chiave da un campo all'altro.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
voci	Matrice di voci. Ogni elemento dell'array può contenere `source` `overwriteIfExists` campi e. `target`	Sì		Numero massimo di iscrizioni: 5
source	La chiave per muoversi	Sì		Lunghezza massima: 128. Profondità massima della chiave annidata: 3
target	La chiave verso cui passare	Sì		Lunghezza massima: 128. Profondità massima della chiave annidata: 3
overwriteIfExists	Se lo impostate su`true`, il valore esistente viene sovrascritto se `key` già presente nell'evento. Il valore predefinito è `false`.	No	false	Nessun limite

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata moveKeys conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

RenameKeys

Usa il renameKeys processore per rinominare le chiavi in un evento di registro.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
voci	Matrice di voci. Ogni elemento dell'array può contenere `key` `overwriteIfExists` campi e. `target`	Sì	Nessun limite	Numero massimo di iscrizioni: 5
Chiave	La chiave per rinominare	Sì	Nessun limite	Lunghezza massima: 128.
target	Il nuovo nome della chiave	Sì	Nessun limite	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
overwriteIfExists	Se lo impostate su`true`, il valore esistente viene sovrascritto se `key` già presente nell'evento. Il valore predefinito è `false`.	No	false	Nessun limite

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata renameKeys conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

CopyValue

Usa il copyValue processore per copiare i valori all'interno di un evento di registro. È inoltre possibile utilizzare questo processore per aggiungere metadati agli eventi di registro, copiando i valori delle seguenti chiavi di metadati negli eventi di registro:@logGroupName,,,@logGroupStream. @accountId @regionName Questo è illustrato nell'esempio seguente.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
voci	Matrice di voci. Ogni elemento dell'array può contenere `source` `overwriteIfExists` campi e. `target`	Sì		Numero massimo di iscrizioni: 5
source	La chiave da copiare	Sì		Lunghezza massima: 128. Profondità massima della chiave annidata: 3
target	La chiave in cui copiare il valore	Sì	Nessun limite	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
overwriteIfExists	Se lo impostate su`true`, il valore esistente viene sovrascritto se `key` già presente nell'evento. Il valore predefinito è `false`.	No	false	Nessun limite

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata copyValue conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

Il listToMap processore prende un elenco di oggetti che contengono campi chiave e li converte in una mappa di chiavi di destinazione.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
source	La chiave contiene un elenco di oggetti che verranno convertiti in una mappa ProcessingEvent	Sì		Lunghezza massima: 128. Profondità massima della chiave annidata: 3
Chiave	La chiave dei campi da estrarre come chiavi nella mappa generata	Sì		Lunghezza massima: 128.
ValueKey	Se viene specificato, i valori specificati in questo parametro verranno estratti dagli `source` oggetti e inseriti nei valori della mappa generata. Altrimenti, gli oggetti originali nell'elenco dei sorgenti verranno inseriti nei valori della mappa generata.	No		Lunghezza massima: 128.
target	La chiave del campo che conterrà la mappa generata	No	Nodo radice	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
flatten	Un valore booleano per indicare se l'elenco verrà suddiviso in singoli elementi o se i valori nella mappa generata saranno elenchi. Per impostazione predefinita, i valori per le chiavi corrispondenti saranno rappresentati in un array. `flattentrue`Impostare su per convertire l'array in un singolo valore basato sul valore di`flattenedElement`.	No	false
Elemento appiattito	Se impostate su `flattentrue`, utilizzate `flattenedElement` per specificare quale elemento, `first` o`last`, conservare.	Richiesto quando `flatten` è impostato su `true`		Il valore può essere solo `first` o `last`

Esempio

Prendiamo il seguente esempio di evento di registro:


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

Trasformatore per il caso d'uso 1: flatten è false


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

L'evento di registro trasformato sarebbe il seguente.


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

Trasformatore per il caso d'uso 2: flatten è true ed flattenedElement è first


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

L'evento di registro trasformato sarebbe il seguente.


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

Trasformatore per il caso d'uso 3: flatten è true ed flattenedElement è last


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

L'evento di registro trasformato sarebbe il seguente.


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

Processori di conversione di tipi di dati

Convertitore di tipo

Utilizzate il typeConverter processore per convertire un tipo di valore associato alla chiave specificata nel tipo specificato. È un processore di casting che modifica i tipi dei campi specificati. I valori possono essere convertiti in uno dei seguenti tipi di dati:integer,, double e. string boolean

Campo Descrizione Obbligatorio? Predefinita Limiti

Campo	Descrizione	Obbligatorio?	Limiti
voci	Matrice di voci. Ogni elemento dell'array deve contenere `key` `type` campi.	Sì	Numero massimo di iscrizioni: 10
Chiave	La chiave con il valore da convertire in un tipo diverso	Sì	Lunghezza massima: 128. Profondità massima della chiave annidata: 3
tipo	Il tipo in cui eseguire la conversione. I valori validi sono `integerdouble`, `string` e`boolean`.	Sì

voci

Matrice di voci. Ogni elemento dell'array deve contenere key type campi.

Sì

Numero massimo di iscrizioni: 10

Chiave

La chiave con il valore da convertire in un tipo diverso

Sì

Lunghezza massima: 128.

Profondità massima della chiave annidata: 3

tipo

Il tipo in cui eseguire la conversione. I valori validi sono integerdouble, string eboolean.

Sì

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata typeConverter conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

DateTimeConverter

Utilizzate il datetimeConverter processore per convertire una stringa datetime in un formato specificato dall'utente.

Campo	Descrizione	Obbligatorio?	Predefinita	Limiti
source	La chiave a cui applicare la conversione della data.	Sì		Numero massimo di iscrizioni: 10
Match Patterns	Un elenco di modelli da abbinare al campo `source`	Sì		Numero massimo di iscrizioni: 5
target	Il campo JSON in cui memorizzare il risultato.	Sì		Lunghezza massima: 128. Profondità massima della chiave annidata: 3
Formato di destinazione	Il formato datetime da utilizzare per i dati convertiti nel campo di destinazione.	No	`yyyy-MM-dd'T'HH:mm:ss.SSS'Z`	Lunghezza massima: 64
Fuso orario di origine	Il fuso orario del campo sorgente. Per un elenco dei valori possibili, consulta Java Supported Zone Ids and Offsets.	No	UTC	Lunghezza minima:1
Fuso orario di destinazione	Il fuso orario del campo di destinazione. Per un elenco dei valori possibili, consulta Java Supported Zone Ids and Offsets.	No	UTC	Lunghezza minima:1
locale	La localizzazione del campo sorgente. Per un elenco di valori possibili, vedete Metodo Locale getAvailableLocales () in Java con esempi.	Sì		Lunghezza minima:1

Esempio

Prendiamo il seguente esempio di evento di registro:


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

La configurazione del trasformatore è questa, utilizzata dateTimeConverter conparseJSON:


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

L'evento di registro trasformato sarebbe il seguente.


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Eliminare un trasformatore log-group-level

Metriche ed errori di trasformazione