Konfigurierbare Prozessoren vom Typ Parser - CloudWatch Amazon-Protokolle
parseJSONGrokcsvparseKeyValue

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Konfigurierbare Prozessoren vom Typ Parser

Dieser Abschnitt enthält Informationen zu den konfigurierbaren Datenparser-Prozessoren, die Sie in einem Log-Event-Transformator verwenden können.

parseJSON

Der ParseJSON-Prozessor analysiert JSON-Protokollereignisse und fügt extrahierte JSON-Schlüssel-Wert-Paare unter dem Ziel ein. Wenn Sie kein Ziel angeben, platziert der Prozessor das Schlüssel-Wert-Paar unter dem Stammknoten. Wenn Sie parseJSON es als ersten Prozessor verwenden, müssen Sie das gesamte Protokollereignis @message als Quellfeld analysieren. Nach der ersten JSON-Analyse können Sie dann bestimmte Felder in nachfolgenden Prozessoren bearbeiten.

Der ursprüngliche @message Inhalt wird nicht geändert, die neuen Schlüssel werden der Nachricht hinzugefügt.

Feld Description Erforderlich? Standard Einschränkungen

Quelle

 Pfad zu dem Feld im Protokollereignis, das analysiert wird. Verwenden Sie die Punktnotation, um auf untergeordnete Felder zuzugreifen. Beispiel: store.book

Nein

@message

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Ziel

 Das Zielfeld der analysierten JSON-Datei

Nein

Parent JSON node

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Beispiel

Angenommen, ein aufgenommenes Protokollereignis sieht wie folgt aus:

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

Wenn wir dann diesen ParseJSON-Prozessor haben:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Grok

Verwenden Sie den Grok-Prozessor, um unstrukturierte Daten mithilfe von Musterabgleich zu analysieren und zu strukturieren. Dieser Prozessor kann auch Felder aus Protokollnachrichten extrahieren.

Feld Description Erforderlich? Standard Einschränkungen Hinweise

Quelle

 Pfad des Felds, auf das der Grok-Matching angewendet werden soll

Nein

@message

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

match

Das Grok-Muster, das mit dem Protokollereignis verglichen werden soll

Ja

Maximale Länge: 512

Maximale Anzahl von Grim-Mustern: 20

Für einige Grok-Mustertypen gelten individuelle Nutzungsbeschränkungen. Jede Kombination der folgenden Muster kann bis zu fünfmal verwendet werden: {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE}

Grok-Muster unterstützen keine Typkonvertierungen.

Für gängige Protokollformatmuster (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG, SYSLOG5424) werden nur die Muster DATA, GREEDYDATA oder GREEDYDATA_MULTILINE unterstützt, sodass sie nach dem allgemeinen Protokollmuster eingefügt werden können.

Alle unterstützten Grok-Muster anzeigen

Struktur eines Grok-Musters

Dies ist die unterstützte Grok-Musterstruktur:

%{PATTERN_NAME:FIELD_NAME}

  • PATTERN_NAME: Bezieht sich auf einen vordefinierten regulären Ausdruck für den Abgleich mit einem bestimmten Datentyp. Es werden nur vordefinierte Grok-Muster unterstützt. Das Erstellen von benutzerdefinierten Mustern ist nicht zulässig.

  • FIELD_NAME: Weist dem extrahierten Wert einen Namen zu. FIELD_NAMEist optional, aber wenn Sie diesen Wert nicht angeben, werden die extrahierten Daten aus dem transformierten Protokollereignis gelöscht. Wenn die Notation mit Punkten FIELD_NAME verwendet wird (z. B. „parent.child“), wird dies als JSON-Pfad betrachtet.

  • Typkonvertierung: Explizite Typkonvertierungen werden nicht unterstützt. Verwenden Sie den TypeConverter Prozessor, um den Datentyp eines beliebigen von Grok extrahierten Werts zu konvertieren.

Um komplexere passende Ausdrücke zu erstellen, können Sie mehrere Grok-Muster kombinieren. Bis zu 20 Grok-Muster können kombiniert werden, um einem Protokollereignis zu entsprechen. Diese Kombination von Mustern %{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data} kann beispielsweise verwendet werden, um Felder aus einem langsamen Redis-Logeintrag wie diesem zu extrahieren:

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

Grok-Beispiele

Beispiel 1: Verwenden Sie Grok, um ein Feld aus unstrukturierten Protokollen zu extrahieren

Beispielprotokoll:

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

Verwendeter Transformator:

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

Ausgabe:

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

Beispielprotokoll:

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

Verwendeter Transformator:

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

Ausgabe:

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

Beispiel 2: Verwenden Sie grok in Kombination mit parseJSON, um Felder aus einem JSON-Protokollereignis zu extrahieren

Beispielprotokoll:

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

Verwendeter Transformator:

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

Ausgabe:

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

Beispiel 3: Grok-Muster mit gepunkteter Anmerkung in FIELD_NAME

Beispielprotokoll:

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

Verwendeter Transformator:

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

Ausgabe:

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

Unterstützte Grok-Muster

In den folgenden Tabellen sind die Muster aufgeführt, die vom grok Prozessor unterstützt werden.

Allgemeine Grok-Muster

Grok-Muster Description Maximales Musterlimit Beispiel
BENUTZERNAME oder BENUTZER Entspricht einem oder mehreren Zeichen, die Kleinbuchstaben (a-z), Großbuchstaben (A-Z), Ziffern (0-9), Punkte (.), Unterstriche (_) oder Bindestriche (-) enthalten können 20

Eingabe: user123.name-TEST

Pattern: %{USERNAME:name}

Ausgang: {"name": "user123.name-TEST"}
INT Entspricht einem optionalen Plus- oder Minuszeichen, gefolgt von einer oder mehreren Ziffern. 20

Eingabe: -456

Pattern: %{INT:num}

Ausgang: {"num": "-456"}
BASE10 NUM Entspricht einer Ganzzahl oder einer Gleitkommazahl mit optionalem Vorzeichen und Dezimaltrennzeichen 20

Eingabe: -0.67

Pattern: %{BASE10NUM:num}

Ausgang: {"num": "-0.67"}
BASE16NUM Entspricht Dezimal- und Hexadezimalzahlen mit einem optionalen Zeichen (+ oder -) und einem optionalen 0x-Präfix 20

Eingabe: +0xA1B2

Pattern: %{BASE16NUM:num}

Ausgang: {"num": "+0xA1B2"}
POSEN Entspricht ganzen positiven Ganzzahlen ohne führende Nullen, die aus einer oder mehreren Ziffern bestehen (1-9 gefolgt von 0-9) 20

Eingabe: 123

Pattern: %{POSINT:num}

Ausgang: {"num": "123"}
NICHT NEGATIV Entspricht allen ganzen Zahlen (bestehend aus einer oder mehreren Ziffern 0-9), einschließlich Null und Zahlen mit führenden Nullen. 20

Eingabe: 007

Pattern: %{NONNEGINT:num}

Ausgang: {"num": "007"}
WORT Entspricht ganzen Wörtern, die aus einem oder mehreren Wortzeichen (\ w) bestehen, einschließlich Buchstaben, Ziffern und Unterstrichen 20

Eingabe: user_123

Pattern: %{WORD:user}

Ausgang: {"user": "user_123"}
KEIN LEERZEICHEN Entspricht einem oder mehreren Zeichen, die keine Leerzeichen sind. 5

Eingabe: hello_world123

Pattern: %{NOTSPACE:msg}

Ausgang: {"msg": "hello_world123"}
SPACE Entspricht null oder mehr Leerzeichen. 5

Eingabe: " "

Pattern: %{SPACE:extra}

Ausgang: {"extra": " "}
DATA Entspricht einem beliebigen Zeichen (außer Zeilenumbruch) null oder öfter, nicht gierig. 5

Eingabe: abc def ghi

Pattern: %{DATA:x} %{DATA:y}

Ausgang: {"x": "abc", "y": "def ghi"}
GIERIGE DATEN Entspricht einem beliebigen Zeichen (außer Newline) null Mal oder öfter, gierig. 5

Eingabe: abc def ghi

Pattern: %{GREEDYDATA:x} %{GREEDYDATA:y}

Ausgang: {"x": "abc def", "y": "ghi"}
GREEDYDATA_MULTILINE Entspricht einem beliebigen Zeichen (einschließlich Zeilenumbruch) null Mal oder öfter, gierig. 1

Eingabe:

abc

def

ghi

Pattern: %{GREEDYDATA_MULTILINE:data}

Ausgabe: {"data": "abc\ndef\nghi"}
ZEICHENFOLGE IN ANFÜHRUNGSZEICHEN Findet Zeichenketten in Anführungszeichen (einfache oder doppelte Anführungszeichen) mit maskierten Zeichen. 20

Eingabe: "Hello, world!"

Pattern: %{QUOTEDSTRING:msg}

Ausgang: {"msg": "Hello, world!"}
UUID Entspricht einem Standard-UUID-Format: 8 Hexadezimalzeichen, gefolgt von drei Gruppen von 4 Hexadezimalzeichen und endend mit 12 Hexadezimalzeichen, die alle durch Bindestriche getrennt sind. 20

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

Pattern: %{UUID:id}

Ausgang: {"id": "550e8400-e29b-41d4-a716-446655440000"}
URNE Entspricht der URN-Syntax (Uniform Resource Name). 20

Eingabe: urn:isbn:0451450523

Pattern: %{URN:urn}

Ausgang: {"urn": "urn:isbn:0451450523"}

AWS Grok-Muster

Muster Description Maximales Musterlimit Beispiel

ARN

Stimmt mit AWS Amazon-Ressourcennamen (ARNs) überein und erfasst die Partition (aws,aws-cn, oderaws-us-gov), den Service, die Region, die Konto-ID und bis zu 5 hierarchische Ressourcen-IDs, getrennt durch Schrägstriche. Die fehlenden Informationen zwischen Doppelpunkten ARNs werden nicht abgeglichen.

 5

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

Pattern: %{ARN:arn}

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

Grok-Muster im Netzwerk

Grok-Muster Description Maximales Musterlimit Beispiel
CISCOMAC Entspricht einer MAC-Adresse im 4-4-4-Hexadezimalformat. 20

Eingabe: 0123.4567.89AB

Pattern: %{CISCOMAC:MacAddress}

Ausgang: {"MacAddress": "0123.4567.89AB"}
WINDOWS, MAC Entspricht einer MAC-Adresse im Hexadezimalformat mit Bindestrichen 20

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

Pattern: %{WINDOWSMAC:MacAddress}

Ausgang: {"MacAddress": "01-23-45-67-89-AB"}
COMMONMAC Entspricht einer MAC-Adresse im Hexadezimalformat mit Doppelpunkten. 20

Eingabe: 01:23:45:67:89:AB

Pattern: %{COMMONMAC:MacAddress}

Ausgang: {"MacAddress": "01:23:45:67:89:AB"}
MAC Entspricht einem der CISCOMAC-, WINDOWSMAC- oder COMMONMAC-Grok-Muster 20

Eingabe: 01:23:45:67:89:AB

Pattern: %{MAC:m1}

Ausgang: {"m1":"01:23:45:67:89:AB"}
IPV6 Stimmt mit IPv6 Adressen überein, einschließlich komprimierter Formulare und Adressen mit IPv4 -Zuordnung IPv6 . 5

Eingabe: 2001:db8:3333:4444:5555:6666:7777:8888

Pattern: %{IPV6:ip}

Ausgang: {"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}
IPV4 Stimmt mit einer IPv4 Adresse überein. 20

Eingabe: 192.168.0.1

Pattern: %{IPV4:ip}

Ausgang: {"ip": "192.168.0.1"}
IP IPv6 Entspricht entweder Adressen, die von% {IPv6} unterstützt werden, oder IPv4 Adressen, die von% {IPv4} unterstützt werden 5

Eingabe: 192.168.0.1

Pattern: %{IP:ip}

Ausgang: {"ip": "192.168.0.1"}
HOSTNAME oder HOST Entspricht Domainnamen, einschließlich Subdomänen 5

Eingabe: server-01.internal-network.local

Pattern: %{HOST:host}

Ausgang: {"host": "server-01.internal-network.local"}
IP ODER HOST Entspricht entweder einem Hostnamen oder einer IP-Adresse 5

Eingabe: 2001:db8:3333:4444:5555:6666:7777:8888

Pattern: %{IPORHOST:ip}

Ausgang: {"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}
HOSTPORT Entspricht einer IP-Adresse oder einem Hostnamen, wie sie vom Muster% {IPORHOST} unterstützt werden, gefolgt von einem Doppelpunkt und einer Portnummer, wobei der Port in der Ausgabe als „PORT“ erfasst wird. 5

Eingabe: 192.168.1.1:8080

Pattern: %{HOSTPORT:ip}

Ausgang: {"ip":"192.168.1.1:8080","PORT":"8080"}
URIHOST Entspricht einer IP-Adresse oder einem Hostnamen, wie sie vom Muster% {IPORHOST} unterstützt werden, optional gefolgt von einem Doppelpunkt und einer Portnummer, wobei der Port als „Port“ erfasst wird, falls vorhanden. 5

Eingabe: example.com:443 10.0.0.1

Pattern: %{URIHOST:host} %{URIHOST:ip}

Ausgang: {"host":"example.com:443","port":"443","ip":"10.0.0.1"}

Muster für Pfadwechsel

Grok-Muster Description Maximales Musterlimit Beispiel
UNIXPATH Entspricht URL-Pfaden, möglicherweise einschließlich Abfrageparametern. 20

Eingabe: /search?q=regex

Pattern: %{UNIXPATH:path}

Ausgang: {"path":"/search?q=regex"}
WINPATH Entspricht Windows-Dateipfaden. 5

Eingabe: C:\Users\John\Documents\file.txt

Pattern: %{WINPATH:path}

Ausgang: {"path": "C:\\Users\\John\\Documents\\file.txt"}
PATH Entspricht entweder URL- oder Windows-Dateipfaden 5

Eingabe: /search?q=regex

Pattern: %{PATH:path}

Ausgang: {"path":"/search?q=regex"}
TTY Entspricht Unix-Gerätepfaden für Terminals und Pseudoterminals. 20

Eingabe: /dev/tty1

Pattern: %{TTY:path}

Ausgang: {"path":"/dev/tty1"}
URIPROTO Entspricht Buchstaben, optional gefolgt von einem Pluszeichen (+) und zusätzlichen Buchstaben oder Pluszeichen (+) 20

Eingabe: web+transformer

Pattern: %{URIPROTO:protocol}

Ausgang: {"protocol":"web+transformer"}
URIPATH Entspricht der Pfadkomponente einer URI 20

Eingabe: /category/sub-category/product_name

Pattern: %{URIPATH:path}

Ausgang: {"path":"/category/sub-category/product_name"}
URIPARAM Entspricht den URL-Abfrageparametern 5

Eingabe: ?param1=value1&param2=value2

Pattern: %{URIPARAM:url}

Ausgang: {"url":"?param1=value1&param2=value2"}
URIPATHPARAM Entspricht einem URI-Pfad, optional gefolgt von Abfrageparametern 5

Eingabe: /category/sub-category/product?id=12345&color=red

Pattern: %{URIPATHPARAM:path}

Ausgang: {"path":"/category/sub-category/product?id=12345&color=red"}
URI Entspricht einer vollständigen URI 5

Eingabe: https://user:password@example.com/path/to/resource?param1=value1&param2=value2

Pattern: %{URI:uri}

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

Grok-Muster für Datum und Uhrzeit

Grok-Muster Description Maximales Musterlimit Beispiel
MONAT Entspricht vollständigen oder abgekürzten englischen Monatsnamen als ganze Wörter 20

Eingabe: Jan

Pattern: %{MONTH:month}

Ausgang: {"month":"Jan"}

Eingabe: January

Pattern: %{MONTH:month}

Ausgang: {"month":"January"}
MONAT, ZAHL Entspricht Monatszahlen von 1 bis 12, mit optionaler führender Null für einstellige Monate. 20

Eingabe: 5

Pattern: %{MONTHNUM:month}

Ausgang: {"month":"5"}

Eingabe: 05

Pattern: %{MONTHNUM:month}

Ausgang: {"month":"05"}
MONTHNUM2 Entspricht zweistelligen Monatszahlen von 01 bis 12. 20

Eingabe: 05

Pattern: %{MONTHNUM2:month}

Ausgang: {"month":"05"}
MONAT/TAG Entspricht dem Tag des Monats von 1 bis 31, optional mit vorangestellter Null. 20

Eingabe: 31

Pattern: %{MONTHDAY:monthDay}

Ausgang: {"monthDay":"31"}
JAHR Entspricht dem Jahr zwei- oder vierstellig 20

Eingabe: 2024

Pattern: %{YEAR:year}

Ausgang: {"year":"2024"}

Eingabe: 24

Pattern: %{YEAR:year}

Ausgang: {"year":"24"}
TAG Entspricht vollständigen oder abgekürzten Tagesnamen. 20

Eingabe: Tuesday

Pattern: %{DAY:day}

Ausgang: {"day":"Tuesday"}
STUNDE Entspricht der Stunde im 24-Stunden-Format mit einer optionalen führenden Null (0) 0—23. 20

Eingabe: 22

Pattern: %{HOUR:hour}

Ausgang: {"hour":"22"}
MINUTE Entspricht Minuten (00-59). 20

Eingabe: 59

Pattern: %{MINUTE:min}

Ausgang: {"min":"59"}
SECOND Entspricht einer Zahl, die Sekunden (0) 0-60 darstellt, optional gefolgt von einem Dezimalpunkt oder Doppelpunkt und einer oder mehreren Ziffern für Minutenbruchteile 20

Eingabe: 3

Pattern: %{SECOND:second}

Ausgang: {"second":"3"}

Eingabe: 30.5

Pattern: %{SECOND:minSec}

Ausgang: {"minSec":"30.5"}

Eingabe: 30:5

Pattern: %{SECOND:minSec}

Ausgang: {"minSec":"30:5"}
TIME Entspricht einem Zeitformat mit Stunden, Minuten und Sekunden im Format (H) H:mm :( s) s. Sekunden beinhalten Schaltsekunden (0) 0—60. 20

Eingabe: 09:45:32

Pattern: %{TIME:time}

Ausgang: {"time":"09:45:32"}
DATE_US Entspricht einem Datum im Format (M) M/ (d) d/ (yy) yy oder (M) M- (d) d- (yy) yy. 20

Eingabe: 11/23/2024

Pattern: %{DATE_US:date}

Ausgang: {"date":"11/23/2024"}

Eingabe: 1-01-24

Pattern: %{DATE_US:date}

Ausgang: {"date":"1-01-24"}
DATE_EU Entspricht dem Datum im Format (d) d/ (M) M/ (yy) yy, (d) d- (M) M- (yy) yy oder (d) d. (M) M. (yy) yy. 20

Eingabe: 23/11/2024

Pattern: %{DATE_EU:date}

Ausgang: {"date":"23/11/2024"}

Eingabe: 1.01.24

Pattern: %{DATE_EU:date}

Ausgang: {"date":"1.01.24"}
ISO8601_TIMEZONE Entspricht dem UTC-Offset 'Z' oder dem Zeitzonen-Offset mit optionalem Doppelpunkt im Format [+-] (H) H (:) mm). 20

Eingabe: +05:30

Pattern: %{ISO8601_TIMEZONE:tz}

Ausgang: {"tz":"+05:30"}

Eingabe: -530

Pattern: %{ISO8601_TIMEZONE:tz}

Ausgang: {"tz":"-530"}

Eingabe: Z

Pattern: %{ISO8601_TIMEZONE:tz}

Ausgang: {"tz":"Z"}
ISO8601_SEKUNDE Entspricht einer Zahl, die Sekunden (0) 0-60 darstellt, optional gefolgt von einem Dezimalpunkt oder Doppelpunkt und einer oder mehreren Ziffern für Sekundenbruchteile 20

Eingabe: 60

Pattern: %{ISO8601_SECOND:second}

Ausgang: {"second":"60"}
TIMESTAMP_ 01 ISO86 Entspricht dem ISO86 01 Datetime-Format (yy) yy- (M) M- (d) dT (H) H:mm :( (s) s) (Z| [+-] (H) H:mm) mit optionalen Sekunden und Zeitzone. 20

Eingabe: 2023-05-15T14:30:00+05:30

Pattern: %{TIMESTAMP_ISO8601:timestamp}

Ausgang: {"timestamp":"2023-05-15T14:30:00+05:30"}

Eingabe: 23-5-1T1:25+5:30

Pattern: %{TIMESTAMP_ISO8601:timestamp}

Ausgang: {"timestamp":"23-5-1T1:25+5:30"}

Eingabe: 23-5-1T1:25Z

Pattern: %{TIMESTAMP_ISO8601:timestamp}

Ausgang: {"timestamp":"23-5-1T1:25Z"}
DATE Entspricht entweder einem Datum im US-Format mit% {DATE_US} oder einem Datum im EU-Format mit% {DATE_EU} 20

Eingabe: 11/29/2024

Pattern: %{DATE:date}

Ausgang: {"date":"11/29/2024"}

Eingabe: 29.11.2024

Pattern: %{DATE:date}

Ausgang: {"date":"29.11.2024"}
DATUMSSTEMPEL Entspricht dem Muster% {DATE} gefolgt vom Muster% {TIME}, getrennt durch Leerzeichen oder Bindestrich. 20

Eingabe: 29-11-2024 14:30:00

Pattern: %{DATESTAMP:dateTime}

Ausgang: {"dateTime":"29-11-2024 14:30:00"}
TZ Entspricht gängigen Abkürzungen für Zeitzonen (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC). 20

Eingabe: PDT

Pattern: %{TZ:tz}

Ausgang: {"tz":"PDT"}
DATESTAMP_ RFC822 Entspricht Datum und Uhrzeit im folgenden Format: Tag MonthName (D) D (YY) YY (H) H:mm :( s) s Zeitzone 20

Eingabe: Monday Jan 5 23 1:30:00 CDT

Pattern: %{DATESTAMP_RFC822:dateTime}

Ausgang: {"dateTime":"Monday Jan 5 23 1:30:00 CDT"}

Eingabe: Mon January 15 2023 14:30:00 PST

Pattern: %{DATESTAMP_RFC822:dateTime}

Ausgang: {"dateTime":"Mon January 15 2023 14:30:00 PST"}
DATESTAMP_ RFC2822 Entspricht dem RFC2822 Datums-/Uhrzeitformat: Tag, (d) d MonthName (yy) yy (H) H:mm :( s) s Z| [+-] (H) H:mm 20

Eingabe: Mon, 15 May 2023 14:30:00 +0530

Pattern: %{DATESTAMP_RFC2822:dateTime}

Ausgang: {"dateTime":"Mon, 15 May 2023 14:30:00 +0530"}

Eingabe: Monday, 15 Jan 23 14:30:00 Z

Pattern: %{DATESTAMP_RFC2822:dateTime}

Ausgang: {"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}
DATESTAMP_OTHER Entspricht Datum und Uhrzeit im folgenden Format: Tag MonthName (d) d (H) h:mm :( s) s Zeitzone (yy) yy 20

Eingabe: Mon May 15 14:30:00 PST 2023

Pattern: %{DATESTAMP_OTHER:dateTime}

Ausgang: {"dateTime":"Mon May 15 14:30:00 PST 2023"}
DATESTAMP_EVENTLOG Entspricht dem kompakten Datetime-Format ohne Trennzeichen: (yy) yymm (d) d (H) Hmm (s) s 20

Eingabe: 20230515143000

Pattern: %{DATESTAMP_EVENTLOG:dateTime}

Ausgang: {"dateTime":"20230515143000"}

Loggen Sie die Grok-Muster ein

Grok-Muster Description Maximales Musterlimit Beispiel
PROTOKOLLEBENE Entspricht den Standardprotokollebenen mit unterschiedlichen Groß- und Kleinschreibung und Abkürzungen, einschließlich der folgenden: Alert/ALERTTrace/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

Eingabe: INFO

Pattern: %{LOGLEVEL:logLevel}

Ausgang: {"logLevel":"INFO"}
HTTP-DATUM Entspricht dem Datums- und Uhrzeitformat, das häufig in Protokolldateien verwendet wird. Format: (d) MonthName d/ (yy) yy :( H) H:mm :( s) s Zeitzone: Entspricht vollständigen oder abgekürzten englischen Monatsnamen (Beispiel MonthName: „Jan“ oder „January“) Zeitzone: Entspricht dem% {INT} -Grok-Muster 20

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

Pattern: %{HTTPDATE:date}

Ausgang: {"date":"23/Nov/2024:14:30:00 +0640"}
SYSLOG-ZEITSTEMPEL Entspricht dem Datumsformat mit MonthName (d) d (H) H:mm :( s) s MonthName: Entspricht vollständigen oder abgekürzten englischen Monatsnamen (Beispiel: „Jan“ oder „January“) 20

Eingabe: Nov 29 14:30:00

Pattern: %{SYSLOGTIMESTAMP:dateTime}

Ausgang: {"dateTime":"Nov 29 14:30:00"}
PROG Entspricht einem Programmnamen, der aus einer Zeichenfolge aus Buchstaben, Ziffern, Punkt, Unterstrich, Schrägstrich, Prozentzeichen und Bindestrich besteht. 20

Eingabe: user.profile/settings-page

Pattern: %{PROG:program}

Ausgang: {"program":"user.profile/settings-page"}
SYSLOGPROG Entspricht dem PROG-Grok-Muster, optional gefolgt von einer Prozess-ID in eckigen Klammern. 20

Eingabe: user.profile/settings-page[1234]

Pattern: %{SYSLOGPROG:programWithId}

Ausgang: {"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}
SYSLOGHOST Entspricht entweder einem% {HOST} - oder% {IP} -Muster 5

Eingabe: 2001:db8:3333:4444:5555:6666:7777:8888

Pattern: %{SYSLOGHOST:ip}

Ausgang: {"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}
SYSLOG-EINRICHTUNG Entspricht der Syslog-Priorität im Dezimalformat. Der Wert sollte in eckige Klammern (<>) eingeschlossen werden. 20

Eingabe: <13.6>

Pattern: %{SYSLOGFACILITY:syslog}

Ausgang: {"syslog":"<13.6>","facility":"13","priority":"6"}

Gängige Log-Grok-Muster

Sie können vordefinierte benutzerdefinierte Grok-Muster verwenden, um den Protokollformaten von Apache, NGINX und Syslog Protocol (RFC 5424) zu entsprechen. Wenn Sie diese spezifischen Muster verwenden, müssen sie die ersten Muster in Ihrer passenden Konfiguration sein, und ihnen können keine anderen Muster vorausgehen. Außerdem können Sie ihnen nur mit genau einem DATA folgen. GREEDYDATA- oder GREEDYDATA_MULTILINE-Muster.

Grok-Muster Description Maximaler Grenzwert für Muster

APACHE_ACCESS_LOG

Entspricht den Apache-Zugriffsprotokollen

1

NGINX_ACCESS_LOG

Entspricht den NGINX-Zugriffsprotokollen

1

SYSLOG5424

Entspricht den Protokollen des Syslog-Protokolls (RFC 5424)

1

Im Folgenden finden Sie gültige und ungültige Beispiele für die Verwendung dieser gängigen Protokollformatmuster.

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

Beispiele für gängige Protokollformate

Beispiel für ein Apache-Protokoll

Beispielprotokoll:

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

Transformator:

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

Ausgabe:

{
    "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"
}
Beispiel für ein NGINX-Protokoll

Beispielprotokoll:

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"

Transformator:

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

Ausgabe:

{
    "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"
}
Beispiel für ein Syslog-Protokoll (RFC 5424)

Beispielprotokoll:

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

Transformator:

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

Ausgabe:

{
  "pri": 165,
  "version": 1,
  "timestamp": "2003-10-11T22:14:15.003Z",
  "hostname": "mymachine.example.com",
  "app": "evntslog",
  "msg_id": "ID47",
  "structured_data": "exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"",
  "message": "[examplePriority@32473 class=\"high\"]"
}

csv

Der CSV-Prozessor analysiert kommagetrennte Werte (CSV) aus den Protokollereignissen in Spalten.

Feld Description Erforderlich? Standard Einschränkungen

Quelle

 Pfad zu dem Feld im Protokollereignis, das analysiert werden soll

Nein

@message

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

delimiter

 Das Zeichen, das zur Trennung der einzelnen Spalten im ursprünglichen Protokollereignis mit kommagetrennten Werten verwendet wurde

Nein

,

Maximale Länge: 1, es sei denn, der Wert ist oder \t \s

Zeichen in Anführungszeichen

 Zeichen, das als Textqualifizierer für eine einzelne Datenspalte verwendet wird

Nein

"

Maximale Länge: 1

Spalten

 Liste der Namen, die für die Spalten im transformierten Protokollereignis verwendet werden sollen.

Nein

[column_1, column_2 ...]

Maximale Anzahl von CSV-Spalten: 100

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Die Einstellung delimiter \t auf trennt jede Spalte durch ein Tabulatorzeichen und \t jede Spalte durch ein einzelnes Leerzeichen.

Beispiel

Angenommen, ein Teil eines aufgenommenen Protokollereignisses sieht wie folgt aus:

'Akua Mansa':28:'New York: USA'

Angenommen, wir verwenden nur den CSV-Prozessor: 

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

Das transformierte Protokollereignis wäre das Folgende.

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

parseKeyValue

Verwenden Sie den parseKeyValueProzessor, um ein bestimmtes Feld in Schlüssel-Wert-Paare zu zerlegen. Mit den folgenden Optionen können Sie den Prozessor so anpassen, dass er Feldinformationen analysiert.

Feld Description Erforderlich? Standard Einschränkungen

Quelle

 Pfad zu dem Feld im Protokollereignis, das analysiert werden soll

Nein

@message

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Ziel

 Das Zielfeld, in das die extrahierten Schlüssel-Wert-Paare eingefügt werden sollen

Nein

Höchstlänge: 128

FieldDelimiter

 Die Feldtrennzeichenfolge, die zwischen Schlüssel-Wert-Paaren in den ursprünglichen Protokollereignissen verwendet wird

Nein

&

Höchstlänge: 128

keyValueDelimiter

 Die Trennzeichenfolge, die zwischen dem Schlüssel und dem Wert in jedem Paar im transformierten Protokollereignis verwendet werden soll

Nein

=

Höchstlänge: 128

nonMatchValue

Ein Wert, der in das Wertfeld im Ergebnis eingefügt werden soll, wenn ein Schlüssel-Wert-Paar nicht erfolgreich aufgeteilt wurde.

Nein

Höchstlänge: 128

keyPrefix

Wenn Sie allen transformierten Schlüsseln ein Präfix hinzufügen möchten, geben Sie es hier an.

Nein

Höchstlänge: 128

overwriteIfExists

 Ob der Wert überschrieben werden soll, wenn der Zielschlüssel bereits existiert

Nein

false

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Angenommen, wir verwenden die folgende Prozessorkonfiguration: 

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

Das transformierte Protokollereignis wäre das Folgende.

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