Processeurs configurables de type analyseur - Amazon CloudWatch Logs
parseJSONgrokcsvparseKeyValue

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Processeurs configurables de type analyseur

Cette section contient des informations sur les processeurs d'analyse de données configurables que vous pouvez utiliser dans un transformateur d'événements de journalisation.

parseJSON

Le processeur ParseJSON analyse les événements du journal JSON et insère les paires clé-valeur JSON extraites sous la destination. Si vous ne spécifiez pas de destination, le processeur place la paire clé-valeur sous le nœud racine. Lors de l'utilisation en parseJSON tant que premier processeur, vous devez analyser l'intégralité de l'événement du journal en utilisant @message comme champ source. Après l'analyse JSON initiale, vous pouvez ensuite manipuler des champs spécifiques dans les processeurs suivants.

Le @message contenu original n'est pas modifié, les nouvelles clés sont ajoutées au message.

Champ Description Obligatoire ? Par défaut Restrictions

source

 Chemin d'accès au champ du journal des événements qui sera analysé. Utilisez la notation par points pour accéder aux champs secondaires. Par exemple, store.book

Non

@message

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

destination

 Le champ de destination du JSON analysé

Non

Parent JSON node

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

Exemple

Supposons qu'un événement de journal ingéré ressemble à ceci :

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

Ensuite, si nous avons ce processeur ParseJSON :

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

L'événement du journal transformé serait le suivant.

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

grok

Utilisez le processeur grok pour analyser et structurer des données non structurées à l'aide de modèles de correspondance. Ce processeur peut également extraire des champs des messages du journal.

Champ Description Obligatoire ? Par défaut Restrictions Remarques

source

 Chemin du champ sur lequel appliquer la correspondance Grok

Non

@message

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

match

Le modèle grok à associer à l'événement du journal

Oui

Longueur maximale : 512

Motifs de rainure maximum : 20

Certains types de modèles de grok ont des limites d'utilisation individuelles. Toute combinaison des modèles suivants peut être utilisée jusqu'à cinq fois : {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE}

Les modèles Grok ne prennent pas en charge les conversions de type.

Pour les modèles de format de journal courants (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG, SYSLOG5424), seuls les modèles DATA, GREEDYDATA ou GREEDYDATA_MULTILINE peuvent être inclus après le modèle de journal commun.

Voir tous les modèles Grok pris en charge

Structure d'un motif Grok

Voici la structure de modèle de grok prise en charge :

%{PATTERN_NAME:FIELD_NAME}

  • PATTERN_NAME : fait référence à une expression régulière prédéfinie pour faire correspondre un type de données spécifique. Seuls les modèles de grok prédéfinis sont pris en charge. La création de modèles personnalisés n'est pas autorisée.

  • FIELD_NAME : Attribue un nom à la valeur extraite. FIELD_NAMEest facultatif, mais si vous ne spécifiez pas cette valeur, les données extraites seront supprimées de l'événement du journal transformé. S'il FIELD_NAME utilise une notation en pointillés (par exemple, « parent.child »), il est considéré comme un chemin JSON.

  • Conversion de type : les conversions de type explicites ne sont pas prises en charge. Utilisez le TypeConverter processeur pour convertir le type de données de toute valeur extraite par grok.

Pour créer des expressions correspondantes plus complexes, vous pouvez combiner plusieurs modèles de grok. Jusqu'à 20 modèles de grok peuvent être combinés pour correspondre à un événement de journal. Par exemple, cette combinaison de modèles %{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data} peut être utilisée pour extraire des champs d'une entrée de journal lent de Redis comme suit :

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

Exemples de grok

Exemple 1 : utiliser grok pour extraire un champ à partir de journaux non structurés

Exemple de journal :

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

Transformateur utilisé :

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

Sortie :

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

Exemple de journal :

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

Transformateur utilisé :

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

Sortie :

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

Exemple 2 : utilisez grok en combinaison avec parseJSON pour extraire des champs d'un événement de journal JSON

Exemple de journal :

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

Transformateur utilisé :

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

Sortie :

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

Exemple 3 : modèle Grok avec annotation en pointillés dans FIELD_NAME

Exemple de journal :

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

Transformateur utilisé :

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

Sortie :

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

Motifs de grok pris en charge

Les tableaux suivants répertorient les modèles pris en charge par le grok processeur.

Motifs généraux de grok

Motif Grok Description Limite maximale de motifs Exemple
NOM D'UTILISATEUR ou UTILISATEUR Correspond à un ou plusieurs caractères pouvant inclure des lettres minuscules (a-z), des lettres majuscules (A-Z), des chiffres (0-9), des points (.), des traits de soulignement (_) ou des traits d'union (-) 20

Entrée : user123.name-TEST

Modèle : %{USERNAME:name}

Sortie : {"name": "user123.name-TEST"}
INT Correspond à un signe plus ou moins facultatif suivi d'un ou de plusieurs chiffres. 20

Entrée : -456

Modèle : %{INT:num}

Sortie : {"num": "-456"}
BASE10 NUM Correspond à un entier ou à un nombre à virgule flottante avec un signe et une virgule décimale facultatifs 20

Entrée : -0.67

Modèle : %{BASE10NUM:num}

Sortie : {"num": "-0.67"}
BASE16NUM Fait correspondre les nombres décimaux et hexadécimaux avec un signe optionnel (+ ou -) et un préfixe 0x facultatif 20

Entrée : +0xA1B2

Modèle : %{BASE16NUM:num}

Sortie : {"num": "+0xA1B2"}
POINTANT Correspond à des entiers entiers positifs sans zéros en tête, composés d'un ou de plusieurs chiffres (1 à 9 suivis de 0 à 9) 20

Entrée : 123

Modèle : %{POSINT:num}

Sortie : {"num": "123"}
NONNEGINT Correspond à tous les nombres entiers (composés d'un ou plusieurs chiffres de 0 à 9), y compris zéro et les nombres avec des zéros en tête. 20

Entrée : 007

Modèle : %{NONNEGINT:num}

Sortie : {"num": "007"}
MOT Correspond à des mots entiers composés d'un ou de plusieurs caractères (\ w), y compris des lettres, des chiffres et des traits de soulignement 20

Entrée : user_123

Modèle : %{WORD:user}

Sortie : {"user": "user_123"}
PAS D'ESPACE Correspond à un ou plusieurs caractères autres que des espaces blancs. 5

Entrée : hello_world123

Modèle : %{NOTSPACE:msg}

Sortie : {"msg": "hello_world123"}
SPACE Correspond à zéro ou plusieurs caractères d'espacement. 5

Entrée : " "

Modèle : %{SPACE:extra}

Sortie : {"extra": " "}
DATA Correspond à n'importe quel caractère (sauf la nouvelle ligne) zéro fois ou plus, ce n'est pas gourmand. 5

Entrée : abc def ghi

Modèle : %{DATA:x} %{DATA:y}

Sortie : {"x": "abc", "y": "def ghi"}
DONNÉES GOURMANDES Correspond à n'importe quel caractère (sauf la nouvelle ligne) zéro fois ou plus, gourmand. 5

Entrée : abc def ghi

Modèle : %{GREEDYDATA:x} %{GREEDYDATA:y}

Sortie : {"x": "abc def", "y": "ghi"}
GREEDYDATA_MULTILINE Correspond à n'importe quel personnage (y compris une nouvelle ligne) zéro fois ou plus, gourmand. 1

Entrée :

abc

def

ghi

Modèle : %{GREEDYDATA_MULTILINE:data}

Sortie : {"data": "abc\ndef\nghi"}
CHAÎNE ENTRE GUILLEMETS Fait correspondre les chaînes entre guillemets (guillemets simples ou doubles) aux caractères échappés. 20

Entrée : "Hello, world!"

Modèle : %{QUOTEDSTRING:msg}

Sortie : {"msg": "Hello, world!"}
UUID Correspond à un format UUID standard : 8 caractères hexadécimaux, suivis de trois groupes de 4 caractères hexadécimaux et se terminant par 12 caractères hexadécimaux, tous séparés par des tirets. 20

Entrée : 550e8400-e29b-41d4-a716-446655440000

Modèle : %{UUID:id}

Sortie : {"id": "550e8400-e29b-41d4-a716-446655440000"}
URNE Correspond à la syntaxe URN (Uniform Resource Name). 20

Entrée : urn:isbn:0451450523

Modèle : %{URN:urn}

Sortie : {"urn": "urn:isbn:0451450523"}

AWS motifs de grok

Modèle Description Limite maximale de motifs Exemple

ARN

Correspond aux noms de ressources AWS Amazon (ARNs), en capturant la partition (awsaws-cn, ouaws-us-gov), le service, la région, l'ID de compte et jusqu'à 5 identifiants de ressources hiérarchiques séparés par des barres obliques. Cela ne correspondra pas ARNs aux informations manquantes entre deux points.

 5

Entrée : arn:aws:iam:us-east-1:123456789012:user/johndoe

Modèle : %{ARN:arn}

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

Modèles de réseaux

Motif Grok Description Limite maximale de motifs Exemple
CISCOMAC Correspond à une adresse MAC au format hexadécimal 4-4-4. 20

Entrée : 0123.4567.89AB

Modèle : %{CISCOMAC:MacAddress}

Sortie : {"MacAddress": "0123.4567.89AB"}
WINDOWSMAC Correspond à une adresse MAC au format hexadécimal avec des tirets 20

Entrée : 01-23-45-67-89-AB

Modèle : %{WINDOWSMAC:MacAddress}

Sortie : {"MacAddress": "01-23-45-67-89-AB"}
MAC COMMUN Correspond à une adresse MAC au format hexadécimal avec deux points. 20

Entrée : 01:23:45:67:89:AB

Modèle : %{COMMONMAC:MacAddress}

Sortie : {"MacAddress": "01:23:45:67:89:AB"}
MAC Correspond à l'un des modèles de grappes CISCOMAC, WINDOWSMAC ou COMMONMAC 20

Entrée : 01:23:45:67:89:AB

Modèle : %{MAC:m1}

Sortie : {"m1":"01:23:45:67:89:AB"}
IPV6 Correspond IPv6 aux adresses, y compris aux formulaires compressés et aux adresses IPv4 mappées IPv6 . 5

Entrée : 2001:db8:3333:4444:5555:6666:7777:8888

Modèle : %{IPV6:ip}

Sortie : {"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}
IPV4 Correspond à une IPv4 adresse. 20

Entrée : 192.168.0.1

Modèle : %{IPV4:ip}

Sortie : {"ip": "192.168.0.1"}
IP Correspond soit IPv6 aux adresses prises en charge par % {IPv6}, soit IPv4 aux adresses prises en charge par % {IPv4} 5

Entrée : 192.168.0.1

Modèle : %{IP:ip}

Sortie : {"ip": "192.168.0.1"}
HOSTNAME ou HOST Correspond aux noms de domaine, y compris les sous-domaines 5

Entrée : server-01.internal-network.local

Modèle : %{HOST:host}

Sortie : {"host": "server-01.internal-network.local"}
IP OU HÔTE Correspond à un nom d'hôte ou à une adresse IP 5

Entrée : 2001:db8:3333:4444:5555:6666:7777:8888

Modèle : %{IPORHOST:ip}

Sortie : {"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}
PORT HÔTE Correspond à une adresse IP ou à un nom d'hôte tel que pris en charge par le modèle % {IPORHOST} suivi de deux points et d'un numéro de port, capturant le port sous la forme « PORT » dans la sortie. 5

Entrée : 192.168.1.1:8080

Modèle : %{HOSTPORT:ip}

Sortie : {"ip":"192.168.1.1:8080","PORT":"8080"}
URI-HOST Correspond à une adresse IP ou à un nom d'hôte tel que pris en charge par le modèle % {IPORHOST}, éventuellement suivi de deux points et d'un numéro de port, capturant le port en tant que « port » s'il est présent. 5

Entrée : example.com:443 10.0.0.1

Modèle : %{URIHOST:host} %{URIHOST:ip}

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

Motifs de bandes de chemins

Motif Grok Description Limite maximale de motifs Exemple
UNIXPATH Correspond aux chemins d'URL, y compris éventuellement les paramètres de requête. 20

Entrée : /search?q=regex

Modèle : %{UNIXPATH:path}

Sortie : {"path":"/search?q=regex"}
WINPATH Correspond aux chemins de fichiers Windows. 5

Entrée : C:\Users\John\Documents\file.txt

Modèle : %{WINPATH:path}

Sortie : {"path": "C:\\Users\\John\\Documents\\file.txt"}
PATH Correspond à une URL ou à un chemin de fichier Windows 5

Entrée : /search?q=regex

Modèle : %{PATH:path}

Sortie : {"path":"/search?q=regex"}
TTY Correspond aux chemins des périphériques Unix pour les terminaux et les pseudo-terminaux. 20

Entrée : /dev/tty1

Modèle : %{TTY:path}

Sortie : {"path":"/dev/tty1"}
URIPROTO Correspond aux lettres, éventuellement suivies d'un caractère plus (+) et de lettres supplémentaires ou de caractères plus (+) 20

Entrée : web+transformer

Modèle : %{URIPROTO:protocol}

Sortie : {"protocol":"web+transformer"}
URIPATH Correspond au composant de chemin d'un URI 20

Entrée : /category/sub-category/product_name

Modèle : %{URIPATH:path}

Sortie : {"path":"/category/sub-category/product_name"}
URIPARAM Correspond aux paramètres de requête d'URL 5

Entrée : ?param1=value1&param2=value2

Modèle : %{URIPARAM:url}

Sortie : {"url":"?param1=value1&param2=value2"}
PARAMÈTRE URIPATH Correspond à un chemin d'URI éventuellement suivi de paramètres de requête 5

Entrée : /category/sub-category/product?id=12345&color=red

Modèle : %{URIPATHPARAM:path}

Sortie : {"path":"/category/sub-category/product?id=12345&color=red"}
URI Correspond à un URI complet 5

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

Modèle : %{URI:uri}

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

Schémas de plage de dates et d'heures

Motif Grok Description Limite maximale de motifs Exemple
MONTH Correspond aux noms de mois anglais complets ou abrégés sous forme de mots entiers 20

Entrée : Jan

Modèle : %{MONTH:month}

Sortie : {"month":"Jan"}

Entrée : January

Modèle : %{MONTH:month}

Sortie : {"month":"January"}
MONTHNUM Correspond aux numéros des mois compris entre 1 et 12, avec un zéro en tête optionnel pour les mois à un chiffre. 20

Entrée : 5

Modèle : %{MONTHNUM:month}

Sortie : {"month":"5"}

Entrée : 05

Modèle : %{MONTHNUM:month}

Sortie : {"month":"05"}
MONTHNUM2 Correspond aux numéros de mois à deux chiffres compris entre 01 et 12. 20

Entrée : 05

Modèle : %{MONTHNUM2:month}

Sortie : {"month":"05"}
JOUR DU MOIS Correspond au jour du mois compris entre 1 et 31, avec un zéro en tête optionnel. 20

Entrée : 31

Modèle : %{MONTHDAY:monthDay}

Sortie : {"monthDay":"31"}
YEAR Correspond à l'année en deux ou quatre chiffres 20

Entrée : 2024

Modèle : %{YEAR:year}

Sortie : {"year":"2024"}

Entrée : 24

Modèle : %{YEAR:year}

Sortie : {"year":"24"}
DAY Correspond aux noms de jour complets ou abrégés. 20

Entrée : Tuesday

Modèle : %{DAY:day}

Sortie : {"day":"Tuesday"}
HOUR Correspond à l'heure au format 24 heures avec un zéro (0) 0-23 en tête en option. 20

Entrée : 22

Modèle : %{HOUR:hour}

Sortie : {"hour":"22"}
MINUTE Correspond aux minutes (00-59). 20

Entrée : 59

Modèle : %{MINUTE:min}

Sortie : {"min":"59"}
SECOND Correspond à un nombre représentant les secondes (0) 0 à 60, éventuellement suivi d'un point décimal ou de deux points et d'un ou plusieurs chiffres pour des fractions de minutes 20

Entrée : 3

Modèle : %{SECOND:second}

Sortie : {"second":"3"}

Entrée : 30.5

Modèle : %{SECOND:minSec}

Sortie : {"minSec":"30.5"}

Entrée : 30:5

Modèle : %{SECOND:minSec}

Sortie : {"minSec":"30:5"}
TIME Correspond à un format horaire avec des heures, des minutes et des secondes au format (H) H:mm : (s) s. Les secondes incluent les secondes intercalaires (0) de 0 à 60. 20

Entrée : 09:45:32

Modèle : %{TIME:time}

Sortie : {"time":"09:45:32"}
DATE_US Correspond à une date au format (M) M/ (d) d/ (yy) yy ou (M) M- (d) d- (yy) yy. 20

Entrée : 11/23/2024

Modèle : %{DATE_US:date}

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

Entrée : 1-01-24

Modèle : %{DATE_US:date}

Sortie : {"date":"1-01-24"}
DATE_EU Correspond à la date au format (d) d/ (M) M/ (yy) yy, (d) d- (M) M- (yy) yy, ou (d) d. (M) M. (yy) yy. 20

Entrée : 23/11/2024

Modèle : %{DATE_EU:date}

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

Entrée : 1.01.24

Modèle : %{DATE_EU:date}

Sortie : {"date":"1.01.24"}
ISO8601_FUSEAU HORAIRE Correspond au décalage UTC « Z » ou au décalage de fuseau horaire avec deux points optionnels au format [+-] (H) H (:) mm. 20

Entrée : +05:30

Modèle : %{ISO8601_TIMEZONE:tz}

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

Entrée : -530

Modèle : %{ISO8601_TIMEZONE:tz}

Sortie : {"tz":"-530"}

Entrée : Z

Modèle : %{ISO8601_TIMEZONE:tz}

Sortie : {"tz":"Z"}
ISO8601_SECONDE Correspond à un nombre représentant les secondes (0) de 0 à 60, éventuellement suivi d'un point décimal ou de deux points et d'un ou plusieurs chiffres pour des fractions de secondes 20

Entrée : 60

Modèle : %{ISO8601_SECOND:second}

Sortie : {"second":"60"}
HORODATAGE_ 01 ISO86 Correspond au format date/heure ISO86 01 (yy) yy- (M) M- (d) dT (H) H:mm : ((s) s) (Z| [+-] (H) H:mm) avec les secondes et le fuseau horaire facultatifs. 20

Entrée : 2023-05-15T14:30:00+05:30

Modèle : %{TIMESTAMP_ISO8601:timestamp}

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

Entrée : 23-5-1T1:25+5:30

Modèle : %{TIMESTAMP_ISO8601:timestamp}

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

Entrée : 23-5-1T1:25Z

Modèle : %{TIMESTAMP_ISO8601:timestamp}

Sortie : {"timestamp":"23-5-1T1:25Z"}
DATE Correspond à une date au format américain en utilisant % {DATE_US} ou au format européen en utilisant % {DATE_EU} 20

Entrée : 11/29/2024

Modèle : %{DATE:date}

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

Entrée : 29.11.2024

Modèle : %{DATE:date}

Sortie : {"date":"29.11.2024"}
HORODATAGE Correspond à % {DATE} suivi du modèle % {TIME}, séparé par un espace ou un trait d'union. 20

Entrée : 29-11-2024 14:30:00

Modèle : %{DATESTAMP:dateTime}

Sortie : {"dateTime":"29-11-2024 14:30:00"}
TZ Correspond aux abréviations de fuseau horaire courantes (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC). 20

Entrée : PDT

Modèle : %{TZ:tz}

Sortie : {"tz":"PDT"}
DATESTAMP_ RFC822 Correspond à la date et à l'heure au format : Jour MonthName (D) D (YY) YY (H) H:mm :( s) s Fuseau horaire 20

Entrée : Monday Jan 5 23 1:30:00 CDT

Modèle : %{DATESTAMP_RFC822:dateTime}

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

Entrée : Mon January 15 2023 14:30:00 PST

Modèle : %{DATESTAMP_RFC822:dateTime}

Sortie : {"dateTime":"Mon January 15 2023 14:30:00 PST"}
DATESTAMP_ RFC2822 Correspond au format RFC2822 date-heure : Jour, (d) d MonthName (yy) yy (H) H:mm :( s) s Z| [+-] (H) H:mm 20

Entrée : Mon, 15 May 2023 14:30:00 +0530

Modèle : %{DATESTAMP_RFC2822:dateTime}

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

Entrée : Monday, 15 Jan 23 14:30:00 Z

Modèle : %{DATESTAMP_RFC2822:dateTime}

Sortie : {"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}
DATESTAMP_AUTRE Correspond à la date et à l'heure au format : Jour MonthName (d) d (H) H:mm :( s) s Fuseau horaire (yy) yy 20

Entrée : Mon May 15 14:30:00 PST 2023

Modèle : %{DATESTAMP_OTHER:dateTime}

Sortie : {"dateTime":"Mon May 15 14:30:00 PST 2023"}
DATESTAMP_EVENTLOG Correspond au format date/heure compact sans séparateurs : (yy) YYmm (d) d (H) Hmm (s) s 20

Entrée : 20230515143000

Modèle : %{DATESTAMP_EVENTLOG:dateTime}

Sortie : {"dateTime":"20230515143000"}

Motifs en bois

Motif Grok Description Limite maximale de motifs Exemple
NIVEAU DU JOURNAL Correspond aux niveaux de log standard dans différentes capitalisations et abréviations, notamment les suivantes :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

Entrée : INFO

Modèle : %{LOGLEVEL:logLevel}

Sortie : {"logLevel":"INFO"}
HTTPDATE Correspond au format de date et d'heure souvent utilisé dans les fichiers journaux. Format : (d) MonthName d/ (yy) yy :( H) H:mm :( s) s Fuseau horaire : correspond aux noms de mois anglais complets ou abrégés (exemple MonthName : « Jan » ou « January ») Fuseau horaire : Correspond au modèle % {INT} grok 20

Entrée : 23/Nov/2024:14:30:00 +0640

Modèle : %{HTTPDATE:date}

Sortie : {"date":"23/Nov/2024:14:30:00 +0640"}
HORODATAGE SYSLOG Correspond au format de date avec MonthName (d) d (H) H:mm :( s) s MonthName : correspond aux noms de mois anglais complets ou abrégés (exemple : « Jan » ou « January ») 20

Entrée : Nov 29 14:30:00

Modèle : %{SYSLOGTIMESTAMP:dateTime}

Sortie : {"dateTime":"Nov 29 14:30:00"}
PROG Correspond à un nom de programme composé d'une chaîne de lettres, de chiffres, de points, d'un trait de soulignement, d'une barre oblique, d'un signe de pourcentage et de tirets. 20

Entrée : user.profile/settings-page

Modèle : %{PROG:program}

Sortie : {"program":"user.profile/settings-page"}
SYSLOGPROG Correspond au modèle PROG grok éventuellement suivi d'un identifiant de processus entre crochets. 20

Entrée : user.profile/settings-page[1234]

Modèle : %{SYSLOGPROG:programWithId}

Sortie : {"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}
HÔTE SYSLOG Correspond à un modèle % {HOST} ou % {IP} 5

Entrée : 2001:db8:3333:4444:5555:6666:7777:8888

Modèle : %{SYSLOGHOST:ip}

Sortie : {"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}
INSTALLATION SYSLOG Correspond à la priorité Syslog au format décimal. La valeur doit être placée entre crochets (<>). 20

Entrée : <13.6>

Modèle : %{SYSLOGFACILITY:syslog}

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

Motifs courants de rainurage en rondins

Vous pouvez utiliser des modèles de grok personnalisés prédéfinis pour correspondre aux formats de journal Apache, NGINX et Syslog Protocol (RFC 5424). Lorsque vous utilisez ces modèles spécifiques, ils doivent être les premiers modèles de votre configuration correspondante, et aucun autre modèle ne peut les précéder. De plus, vous ne pouvez les suivre qu'avec une seule donnée. Modèle GREEDYDATA ou GREEDYDATA_MULTILINE.

Modèle grok Description Limite maximale de motifs

JOURNAL D'ACCÈS APACHE

Correspond aux journaux d'accès Apache

1

JOURNAL D'ACCÈS NGINX

Correspond aux journaux d'accès NGINX

1

SYSLOG5424

Correspond aux journaux du protocole Syslog (RFC 5424)

1

Vous trouverez ci-dessous des exemples valides et non valides d'utilisation de ces modèles de format de journal courants.

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

Exemples de formats de journaux courants

Exemple de journal Apache

Exemple de journal :

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

Transformateur :

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

Sortie :

{
    "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"
}
Exemple de journal NGINX

Exemple de journal :

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"

Transformateur :

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

Sortie :

{
    "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"
}
Exemple de journal du protocole Syslog (RFC 5424)

Exemple de journal :

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

Transformateur :

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

Sortie :

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

Le processeur csv analyse les valeurs séparées par des virgules (CSV) des événements du journal en colonnes.

Champ Description Obligatoire ? Par défaut Restrictions

source

 Chemin d'accès au champ du journal des événements qui sera analysé

Non

@message

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

delimiter

 Le caractère utilisé pour séparer chaque colonne dans le journal des valeurs d'origine séparées par des virgules

Non

,

Longueur maximale : 1 sauf si la valeur est \t ou \s

Citer un personnage

 Caractère utilisé comme qualificatif de texte pour une seule colonne de données

Non

"

Longueur maximale : 1

columns

 Liste des noms à utiliser pour les colonnes de l'événement du journal transformé.

Non

[column_1, column_2 ...]

Nombre maximum de colonnes CSV : 100

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

Le réglage delimiter sur « » \t séparera chaque colonne sur un caractère de tabulation et \t séparera chaque colonne sur un seul caractère d'espace.

Exemple

Supposons qu'une partie d'un événement de journal ingéré ressemble à ceci :

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

Supposons que nous n'utilisions que le processeur CSV : 

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

L'événement du journal transformé serait le suivant.

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

parseKeyValue

Utilisez le parseKeyValueprocesseur pour analyser un champ spécifié en paires clé-valeur. Vous pouvez personnaliser le processeur pour analyser les informations des champs à l'aide des options suivantes.

Champ Description Obligatoire ? Par défaut Restrictions

source

 Chemin d'accès au champ du journal des événements qui sera analysé

Non

@message

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

destination

 Le champ de destination dans lequel placer les paires clé-valeur extraites

Non

Longueur maximale : 128

Délimiteur de champs

 Chaîne de délimitation de champs utilisée entre les paires clé-valeur dans les événements du journal d'origine

Non

&

Longueur maximale : 128

keyValueDelimiter

 Chaîne de délimitation à utiliser entre la clé et la valeur dans chaque paire dans l'événement du journal transformé

Non

=

Longueur maximale : 128

nonMatchValue

Une valeur à insérer dans le champ de valeur du résultat, lorsqu'une paire clé-valeur n'est pas correctement divisée.

Non

Longueur maximale : 128

keyPrefix

Si vous souhaitez ajouter un préfixe à toutes les clés transformées, spécifiez-le ici.

Non

Longueur maximale : 128

overwriteIfExists

 S'il faut remplacer la valeur si la clé de destination existe déjà

Non

false

Exemple

Prenons l'exemple d'événement de journal suivant :

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

Supposons que nous utilisions la configuration de processeur suivante : 

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

L'événement du journal transformé serait le suivant.

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