Prozessoren, die Sie verwenden können - CloudWatch Amazon-Protokolle
Konfigurierbare Prozessoren vom Typ ParserIntegrierte Prozessoren für AWS verkaufte LogsProzessoren mutieren durch ZeichenkettenJSON-Prozessoren mutierenProzessoren für Datentypkonverter

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.

Prozessoren, die Sie verwenden können

Dieser Abschnitt enthält Informationen zu jedem Prozessor, den Sie in einem Log-Event-Transformator verwenden können. Die Prozessoren können in Parser, String-Mutatoren, JSON-Mutatoren und Datumsprozessoren eingeteilt werden.

Inhalt

Konfigurierbare Prozessoren vom Typ Parser

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 Beschreibung 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 Beschreibung 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 aus der Liste der unterstützten 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-Protokolleintrag wie folgt 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 Beschreibung 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 Beschreibung 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 Beschreibung 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 Stimmt entweder mit IPv6 Adressen überein, die von% {IPv6} unterstützt werden, oder IPv4 mit 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 Beschreibung 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 Beschreibung 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 Stimmt mit Minuten überein (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 Datums-/Uhrzeitformat (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"}
DATUM 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 Beschreibung 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 Beschreibung 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\"]"
}

Parse zu OCSF

Der ParseToOCSF-Prozessor konvertiert Protokolle in das Open Cybersecurity Schema Framework (OCSF) -Format.

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

Feld Beschreibung Erforderlich? Standard Einschränkungen

eventSource

Der Dienst oder Prozess, der die Protokollereignisse erzeugt, die mit diesem Prozessor konvertiert werden. Gültige Werte:

Ja

-

-

OCSF-Version

 Die Version des OCSF-Schemas, die für die transformierten Protokollereignisse verwendet werden soll. Derzeit ist der einzige unterstützte Wert V1.1

Ja

V1.1

-

Beispiel

Im folgenden Beispiel werden Amazon VPC-Flow-Logs in das OCSF-Format umgewandelt.

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

csv

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

Feld Beschreibung 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 verwendet wurde, um die einzelnen Spalten im ursprünglichen Protokollereignis mit kommagetrennten Werten zu trennen

Nein

,

Maximale Länge: 1

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

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

Integrierte Prozessoren für AWS verkaufte Logs

Analysieren Sie WAF

Verwenden Sie diesen Prozessor, um verkaufte Logs zu analysieren AWS WAF . Er nimmt den Inhalt von jedem Header-Namen httpRequest.headers und erstellt daraus JSON-Schlüssel mit dem entsprechenden Wert. Das Gleiche tut er auch für. labels Diese Transformationen können das Abfragen von AWS WAF Protokollen erheblich vereinfachen. Weitere Informationen zum AWS WAF Protokollformat finden Sie unter Protokollbeispiele für Web-ACL-Verkehr.

Dieser Prozessor akzeptiert nur @message die Eingabe.

Wichtig

Wenn Sie diesen Prozessor verwenden, muss es der erste Prozessor in Ihrem Transformator sein.

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Prozessorkonfiguration sieht wie folgt aus:

[
    {
        "parseWAF": {}
    }
]

Das transformierte Protokollereignis wäre das Folgende.

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

Analysieren Sie PostGres

Verwenden Sie diesen Prozessor, um verkaufte Protokolle zu analysieren Amazon RDS for PostgreSQL , Felder zu extrahieren und sie in das JSON-Format zu konvertieren. Weitere Informationen zum Protokollformat RDS für PostgreSQL finden Sie unter Datenbankprotokolldateien von RDS for PostgreSQL.

Dieser Prozessor akzeptiert nur @message als Eingabe.

Wichtig

Wenn Sie diesen Prozessor verwenden, muss es der erste Prozessor in Ihrem Transformator sein.

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Prozessorkonfiguration sieht wie folgt aus:

[
    {
        "parsePostgres": {}
    }
]

Das transformierte Protokollereignis wäre das Folgende.

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

Analysieren Sie CloudFront

Verwenden Sie diesen Prozessor, um verkaufte Protokolle zu analysieren, Felder Amazon CloudFront zu extrahieren und sie in das JSON-Format zu konvertieren. Kodierte Feldwerte werden dekodiert. Werte, bei denen es sich um Ganzzahlen und Doppelzahlen handelt, werden als solche behandelt. Weitere Informationen zum Amazon CloudFront Protokollformat finden Sie unter Standardprotokolle (Zugriffsprotokolle) konfigurieren und verwenden.

Dieser Prozessor akzeptiert nur @message als Eingabe.

Wichtig

Wenn Sie diesen Prozessor verwenden, muss es der erste Prozessor in Ihrem Transformator sein.

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Prozessorkonfiguration sieht wie folgt aus:

[
    {
        "parseCloudfront": {}
    }
]

Das transformierte Protokollereignis wäre das Folgende.

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

Verwenden Sie diesen Prozessor, um verkaufte Protokolle zu analysieren Amazon Route 53 Public Data Plane , Felder zu extrahieren und sie in das JSON-Format zu konvertieren. Kodierte Feldwerte werden dekodiert. Dieser Prozessor unterstützt Amazon Route 53 Resolver keine Protokolle.

Dieser Prozessor akzeptiert nur @message als Eingabe.

Wichtig

Wenn Sie diesen Prozessor verwenden, muss es der erste Prozessor in Ihrem Transformator sein.

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Prozessorkonfiguration sieht wie folgt aus:

[
    {
        "parseRoute53": {}
    }
]

Das transformierte Protokollereignis wäre das Folgende.

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

Verwenden Sie diesen Prozessor, um von Amazon VPC verkaufte Protokolle zu analysieren, Felder zu extrahieren und sie in das JSON-Format zu konvertieren. Kodierte Feldwerte werden dekodiert.

Dieser Prozessor akzeptiert nur @message als Eingabe.

Wichtig

Wenn Sie diesen Prozessor verwenden, muss es der erste Prozessor in Ihrem Transformator sein.

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Prozessorkonfiguration sieht wie folgt aus:

[
    {
        "parseVPC": {}
    }
]

Das transformierte Protokollereignis wäre das Folgende.

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

Prozessoren mutieren durch Zeichenketten

lowerCaseString

Der lowerCaseString Prozessor konvertiert eine Zeichenfolge in ihre kleingeschriebene Version.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Mit Schlüsseln

 Eine Liste von Schlüsseln, die in Kleinbuchstaben umgewandelt werden sollen

Ja

Maximale Anzahl von Einträgen: 10

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet lowerCaseString mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

upperCaseString

Der upperCaseString Prozessor konvertiert eine Zeichenfolge in ihre Großbuchstabenversion.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Mit Schlüsseln

 Eine Liste von Schlüsseln, die in Großbuchstaben umgewandelt werden sollen

Ja

Maximale Anzahl von Einträgen: 10

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet upperCaseString mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

SplitString

Der splitString Prozessor ist ein Typ eines String-Mutate-Prozessors, der ein Feld mithilfe eines Trennzeichens in ein Array aufteilt.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Array von Einträgen. Jedes Element im Array muss delimiter Felder enthaltensource.

Ja

Maximale Anzahl von Einträgen: 10

Quelle

 Der Schlüssel des Feldwerts, der geteilt werden soll

Ja

Höchstlänge: 128

delimiter

 Die Trennzeichenfolge, nach der der Feldwert aufgeteilt werden soll

Ja

Höchstlänge: 128

Beispiel 1

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet splitString mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Beispiel 2

Das Trennzeichen, anhand dessen die Zeichenfolge aufgeteilt werden soll, kann mehrere Zeichen lang sein.

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Konfiguration des Transformators sieht wie folgt aus:

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

Das transformierte Protokollereignis wäre das Folgende.

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

SubstituteString

Der substituteString Prozessor ist ein Typ eines String-Mutationsprozessors, der den Wert eines Schlüssels mit einem regulären Ausdruck vergleicht und alle Treffer durch eine Ersatzzeichenfolge ersetzt.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Reihe von Einträgen. Jedes Element im Array muss to Felder sourcefrom, und enthalten.

Ja

Maximale Anzahl von Einträgen: 10

Quelle

 Der Schlüssel des Feldes, das geändert werden soll

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

from

Die Zeichenfolge für reguläre Ausdrücke, die ersetzt werden soll. Spezielle reguläre Zeichen wie [und] müssen mit\\ maskiert werden, wenn doppelte Anführungszeichen verwendet werden, und mit\, wenn einfache Anführungszeichen verwendet werden oder wenn sie über den konfiguriert wurden. AWS Management Console Weitere Informationen finden Sie unter Class Pattern auf der Oracle-Website.

Sie können ein Muster einbinden(...), um eine nummerierte Erfassungsgruppe und (?P<group_name>...) benannte Erfassungsgruppen zu erstellen, auf die im to Feld verwiesen werden kann.

Ja

Höchstlänge: 128

to

 Die Zeichenfolge, die für jede Übereinstimmung von from Rückverweisen auf Erfassungsgruppen ersetzt werden soll, kann verwendet werden. Verwenden Sie die Form $n für nummerierte Gruppen wie $1 und ${group_name} für benannte Gruppen wie $. {my_group} >

Ja

Höchstlänge: 128

Maximale Anzahl von Rückverweisen: 10

Maximale Anzahl doppelter Rückverweise: 2

Beispiel 1

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet substituteString mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Beispiel 2

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet substituteString mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

TrimString

Der trimString Prozessor entfernt Leerzeichen am Anfang und Ende eines Schlüssels.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Mit Schlüsseln

 Eine Liste von Schlüsseln zum Trimmen

Ja

Maximale Anzahl an Einträgen: 10

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet trimString mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

JSON-Prozessoren mutieren

Schlüssel hinzufügen

Verwenden Sie den addKeys Prozessor, um dem Protokollereignis neue Schlüssel-Wert-Paare hinzuzufügen.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder keyvalue, und enthalten.

Ja

Maximale Anzahl von Einträgen: 5

Schlüssel

 Der Schlüssel des neuen Eintrags, der hinzugefügt werden soll

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Wert

 Der Wert des neuen Eintrags, der hinzugefügt werden soll

Ja

Maximale Länge: 256

overwriteIfExists

 Wenn Sie dies auf setzentrue, wird der bestehende Wert überschrieben, falls er im Ereignis key bereits vorhanden ist. Der Standardwert ist false. Nein

false

 Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet addKeys mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Schlüssel löschen

Verwenden Sie den deleteKeys Prozessor, um Felder aus einem Protokollereignis zu löschen. Diese Felder können Schlüssel-Wert-Paare enthalten.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Mit Schlüsseln

 Die Liste der zu löschenden Schlüssel.

Ja

 Kein Limit

Maximale Anzahl an Einträgen: 5

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet deleteKeys mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

{
  "outer_key": {}
}

MoveKeys

Verwenden Sie den moveKeys Prozessor, um eine Taste von einem Feld in ein anderes zu verschieben.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder sourcetarget, und enthalten.

Ja

Maximale Anzahl von Einträgen: 5

Quelle

 Der Schlüssel zum Bewegen

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Ziel

 Der Schlüssel, zu dem gewechselt werden soll

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

overwriteIfExists

 Wenn Sie dies auf setzentrue, wird der vorhandene Wert überschrieben, falls er im key Ereignis bereits vorhanden ist. Der Standardwert ist false. Nein

false

 Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet moveKeys mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Schlüssel umbenennen

Verwenden Sie den renameKeys Prozessor, um Schlüssel in einem Protokollereignis umzubenennen.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder keytarget, und enthalten.

Ja

 Kein Limit

Maximale Anzahl von Einträgen: 5

Schlüssel

 Der Schlüssel zum Umbenennen

Ja

 Kein Limit

Höchstlänge: 128

Ziel

 Der neue Schlüsselname

Ja

 Kein Limit

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

overwriteIfExists

 Wenn Sie dies auf setzentrue, wird der vorhandene Wert überschrieben, falls er im key Ereignis bereits vorhanden ist. Der Standardwert ist false. Nein

false

 Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet renameKeys mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Wert kopieren

Verwenden Sie den copyValue Prozessor, um Werte innerhalb eines Protokollereignisses zu kopieren. Sie können diesen Prozessor auch verwenden, um Metadaten zu Protokollereignissen hinzuzufügen, indem Sie die Werte der folgenden Metadatenschlüssel in die Protokollereignisse kopieren:@logGroupName,@logGroupStream,@accountId,@regionName. Dies wird im folgenden Beispiel veranschaulicht.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder sourcetarget, und enthalten.

Ja

Maximale Anzahl von Einträgen: 5

Quelle

 Der Schlüssel zum Kopieren

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Ziel

 Der Schlüssel, in den der Wert kopiert werden soll

Ja

 Kein Limit

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

overwriteIfExists

 Wenn Sie dies auf setzentrue, wird der vorhandene Wert überschrieben, falls er im key Ereignis bereits vorhanden ist. Der Standardwert ist false. Nein

false

 Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet copyValue mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

Der listToMap Prozessor nimmt eine Liste von Objekten, die Schlüsselfelder enthalten, und konvertiert sie in eine Zuordnung von Zielschlüsseln.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Quelle

 Der Schlüssel in der ProcessingEvent mit einer Liste von Objekten, die in eine Map konvertiert werden

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Schlüssel

 Der Schlüssel der Felder, die als Schlüssel in der generierten Map extrahiert werden sollen

Ja

Höchstlänge: 128

WertSchlüssel

 Wenn dies angegeben ist, werden die Werte, die Sie in diesem Parameter angeben, aus den source Objekten extrahiert und in die Werte der generierten Map eingefügt. Andernfalls werden die Originalobjekte in der Quellliste in die Werte der generierten Map aufgenommen.

Nein

Höchstlänge: 128

Ziel

 Der Schlüssel des Feldes, das die generierte Map enthalten soll

Nein

Stammknoten

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

flatten

Ein boolescher Wert, der angibt, ob die Liste in einzelne Elemente reduziert wird oder ob es sich bei den Werten in der generierten Map um Listen handelt.

Standardmäßig werden die Werte für die passenden Schlüssel in einem Array dargestellt. Auf einstellentrue, flatten um das Array basierend auf dem Wert von in einen einzelnen Wert umzuwandelnflattenedElement.

Nein

false

flattenedElement

 Wenn Sie flatten auf einstellentrue, geben Sie hier flattenedElement an, welches Element first oder last beibehalten werden soll.

Erforderlich, wenn auf gesetzt flatten ist true

Der Wert kann nur first oder sein last

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Transformator für Anwendungsfall 1: flatten ist false

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

Das transformierte Protokollereignis wäre das Folgende.

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

Transformator für Anwendungsfall 2: flatten ist true und flattenedElement ist first

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

Das transformierte Protokollereignis wäre das Folgende.

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

Transformator für Anwendungsfall 3: flatten ist true und flattenedElement ist last

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

Das transformierte Protokollereignis wäre das Folgende.

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

Prozessoren für Datentypkonverter

Typkonverter

Verwenden Sie den typeConverter Prozessor, um einen Wertetyp, der dem angegebenen Schlüssel zugeordnet ist, in den angegebenen Typ zu konvertieren. Es handelt sich um einen Casting-Prozessor, der die Typen der angegebenen Felder ändert. Werte können in einen der folgenden Datentypen konvertiert werden: integerdouble, string und. boolean

Feld Beschreibung Erforderlich? Standard Einschränkungen

Einträge

 Array von Einträgen. Jedes Element im Array muss type Felder enthaltenkey.

Ja

Maximale Anzahl von Einträgen: 10

Schlüssel

 Der Schlüssel mit dem Wert, der in einen anderen Typ konvertiert werden soll

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Typ

 Der Typ, in den konvertiert werden soll. Gültige Werte sind integerdouble, string undboolean.

Ja

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet typeConverter mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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

DateTimeConverter

Verwenden Sie den datetimeConverter Prozessor, um eine Datetime-Zeichenfolge in ein von Ihnen angegebenes Format zu konvertieren.

Feld Beschreibung Erforderlich? Standard Einschränkungen

Quelle

 Der Schlüssel, auf den die Datumskonvertierung angewendet werden soll.

Ja

Maximale Anzahl von Einträgen: 10

Muster abgleichen

 Eine Liste von Mustern, die mit dem Feld abgeglichen werden sollen source

Ja

Maximale Anzahl von Einträgen: 5

Ziel

 Das JSON-Feld, in dem das Ergebnis gespeichert werden soll.

Ja

Höchstlänge: 128

Maximale Tiefe verschachtelter Schlüssel: 3

Zielformat

 Das Datetime-Format, das für die konvertierten Daten im Zielfeld verwendet werden soll.

Nein

yyyy-MM-dd'T'HH:mm:ss.SSS'Z

Maximale Länge: 64

Zeitzone der Quelle

Die Zeitzone des Quellfeldes.

Eine Liste möglicher Werte finden Sie unter Von Java unterstützte Zonen-IDs und Offsets.

Nein

UTC

Mindestlänge:1

Ziel-Zeitzone

Die Zeitzone des Zielfeldes.

Eine Liste möglicher Werte finden Sie unter Von Java unterstützte Zonen-IDs und Offsets.

Nein

UTC

Mindestlänge:1

locale

Das Gebietsschema des Quellfeldes.

Eine Liste möglicher Werte finden Sie unter Locale getAvailableLocales () -Methode in Java mit Beispielen.

Ja

Mindestlänge:1

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:

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

Die Transformer-Konfiguration sieht wie folgt aus und verwendet dateTimeConverter mitparseJSON:

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

Das transformierte Protokollereignis wäre das Folgende.

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