Processeurs configurables de type analyseur Processeurs intégrés pour les AWS journaux vendus Processeurs String Mutate Processeurs de mutation JSON Processeurs de conversion de types de données

Processeurs que vous pouvez utiliser

Cette section contient des informations sur chaque processeur que vous pouvez utiliser dans un transformateur d'événements de journalisation. Les processeurs peuvent être classés en analyseurs, mutateurs de chaînes, mutateurs JSON et processeurs de date.

Table des matières

Processeurs configurables de type analyseur

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 Limites

Champ	Description	Obligatoire ?	Par défaut	Limites
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

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

Champ	Description	Obligatoire ?	Par défaut	Limites	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

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 groupe prédéfinis de la liste des modèles de groupe pris en charge 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 facultatif (+ ou -) et un préfixe 0x facultatif	20	Entrée : `+0xA1B2` Modèle : `%{BASE16NUM:num}` Sortie : `{"num": "+0xA1B2"}`
POINT	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"}`
NON NÉGLIGEABLE	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 grok

Modèle Description Limite maximale de motifs exemple

Modèle	Description	Limite maximale de motifs	exemple
ARN	Correspond aux noms de ressources AWS Amazon (ARNs), en capturant la partition (`awsaws-cn`, ou`aws-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 les 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"}`

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 les deux points.

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 de mois compris entre 1 et 12, avec un zéro initial facultatif 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\"]"
}

Analyser vers OCSF

Le processeur ParseToOCSF convertit les journaux au format Open Cybersecurity Schema Framework (OCSF).

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

Champ	Description	Obligatoire ?	Par défaut	Limites
eventSource	Service ou processus qui produit les événements du journal qui seront convertis avec ce processeur. Les valeurs possibles sont les suivantes : `CloudTrail`pour CloudTrail consigner des événements de gestion, des événements de données Lambda dans CloudTrail ou des événements de données Amazon S3 dans. CloudTrail `Route53Resolver`pour les journaux de requêtes Route 53 Resolver. `VPCFlow`pour les journaux de flux Amazon VPC. `EKSAudit`pour les journaux d'audit Amazon EKS. `AWSWAF`pour les AWS WAF journaux.	Oui	-	-
Version OCSF	Version du schéma OCSF à utiliser pour les événements du journal transformé. Actuellement, la seule valeur prise en charge est `V1.1`	Oui	`V1.1`	-

Exemple

L'exemple suivant transforme les journaux de flux Amazon VPC au format OCSF.


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

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	Limites
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
Personnage de citation	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

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

Processeurs intégrés pour les AWS journaux vendus

Analyser WAF

Utilisez ce processeur pour analyser AWS WAF les journaux vendus. Il prend le contenu de chaque nom d'en-tête httpRequest.headers et crée des clés JSON à partir de celui-ci, avec la valeur correspondante. Il en va de même pourlabels. Ces transformations peuvent faciliter considérablement l'interrogation AWS WAF des journaux. Pour plus d'informations sur le format des AWS WAF journaux, voir Exemples de journaux pour le trafic ACL Web.

Ce processeur n'accepte @message que comme entrée.

Important

Si vous utilisez ce processeur, il doit s'agir du premier processeur de votre transformateur.

Exemple

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


{
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": [],
  "httpRequest": {
    "clientIp": "1.1.1.1",
    "country": "AU",
    "headers": [
      { "name": "Host", "value": "localhost:1989" },
      { "name": "User-Agent", "value": "curl/7.61.1" },
      { "name": "Accept", "value": "*/*" },
      { "name": "x-stm-test", "value": "10 AND 1=1" }
    ],
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": [{ "name": "value" }]
}

La configuration du processeur est la suivante :


[
    {
        "parseWAF": {}
    }
]

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


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

Analyser Postgres

Utilisez ce processeur pour analyser les journaux Amazon RDS for PostgreSQL vendus, extraire des champs et les convertir au format JSON. Pour plus d'informations sur le format de journal RDS pour PostgreSQL, consultez la section Fichiers journaux de base de données RDS pour PostgreSQL.

Ce processeur n'accepte @message que comme entrée.

Important

Si vous utilisez ce processeur, il doit s'agir du premier processeur de votre transformateur.

Exemple

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


2019-03-10 03:54:59 UTC:10.0.0.123(52834):postgres@logtestdb:[20175]:ERROR: column "wrong_column_name" does not exist at character 8

La configuration du processeur est la suivante :


[
    {
        "parsePostgres": {}
    }
]

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


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

ParseCloud Front

Utilisez ce processeur pour analyser les journaux Amazon CloudFront vendus, extraire des champs et les convertir au format JSON. Les valeurs de champ codées sont décodées. Les valeurs qui sont des nombres entiers et des doubles sont traitées comme telles. Pour plus d'informations sur le format des Amazon CloudFront journaux, voir Configurer et utiliser des journaux standard (journaux d'accès).

Ce processeur n'accepte @message que comme entrée.

Important

Si vous utilisez ce processeur, il doit s'agir du premier processeur de votre transformateur.

Exemple

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


2019-12-04  21:02:31   LAX1   392    192.0.2.24    GET    d111111abcdef8.cloudfront.net  /index.html    200    -  Mozilla/5.0%20(Windows%20NT%2010.0;%20Win64;%20x64)%20AppleWebKit/537.36%20(KHTML,%20like%20Gecko)%20Chrome/78.0.3904.108%20Safari/537.36  -  -  Hit    SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==   d111111abcdef8.cloudfront.net  https  23 0.001  -  TLSv1.2    ECDHE-RSA-AES128-GCM-SHA256    Hit    HTTP/2.0   -  -  11040  0.001  Hit    text/html  78 -  -

La configuration du processeur est la suivante :


[
    {
        "parseCloudfront": {}
    }
]

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


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

Par Route 53

Utilisez ce processeur pour analyser les journaux Amazon Route 53 Public Data Plane vendus, extraire des champs et les convertir au format JSON. Les valeurs de champ codées sont décodées. Ce processeur ne prend pas en charge Amazon Route 53 Resolver les journaux.

Ce processeur n'accepte @message que comme entrée.

Important

Si vous utilisez ce processeur, il doit s'agir du premier processeur de votre transformateur.

Exemple

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


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

La configuration du processeur est la suivante :


[
    {
        "parseRoute53": {}
    }
]

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


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

Analyser VPC

Utilisez ce processeur pour analyser les journaux Amazon VPC vended, extraire des champs et les convertir au format JSON. Les valeurs de champ codées sont décodées.

Ce processeur n'accepte @message que comme entrée.

Important

Si vous utilisez ce processeur, il doit s'agir du premier processeur de votre transformateur.

Exemple

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


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

La configuration du processeur est la suivante :


[
    {
        "parseVPC": {}
    }
]

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


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

Processeurs String Mutate

lowerCaseString

Le lowerCaseString processeur convertit une chaîne en sa version minuscule.

Champ	Description	Obligatoire ?	Par défaut	Limites
Avec clés	Une liste de clés à convertir en minuscules	Oui		Nombre maximum d'entrées : 10

Exemple

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


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

La configuration du transformateur est la suivante, lowerCaseString en utilisant parseJSON :


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

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


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

upperCaseString

Le upperCaseString processeur convertit une chaîne en sa version majuscule.

Champ	Description	Obligatoire ?	Par défaut	Limites
Avec clés	Une liste de clés à convertir en majuscules	Oui		Nombre maximum d'entrées : 10

Exemple

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


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

La configuration du transformateur est la suivante, upperCaseString en utilisant parseJSON :


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

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


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

Chaîne divisée

Le splitString processeur est un type de processeur à mutation de chaîne qui divise un champ en un tableau à l'aide d'un caractère de délimitation.

Champ	Description	Obligatoire ?	Limites
entries	Tableau d'entrées. Chaque élément du tableau doit contenir `source` des `delimiter` champs.	Oui	Nombre maximum d'entrées : 10
source	La clé de la valeur du champ à diviser	Oui	Longueur maximale : 128
delimiter	La chaîne de séparation sur laquelle diviser la valeur du champ	Oui	Longueur maximale : 128

Exemple 1

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


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

La configuration du transformateur est la suivante, splitString en utilisant parseJSON :


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

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


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

Exemple 2

Le délimiteur sur lequel la chaîne doit être divisée peut comporter plusieurs caractères.

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


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

La configuration du transformateur est la suivante :


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

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


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

Chaîne de remplacement

Le substituteString processeur est un type de processeur de mutation de chaîne qui fait correspondre la valeur d'une clé à une expression régulière et remplace toutes les correspondances par une chaîne de remplacement.

Champ	Description	Obligatoire ?	Limites
entries	Tableau d'entrées. Chaque élément du tableau doit contenir des `to` champs `sourcefrom`, et.	Oui	Nombre maximum d'entrées : 10
source	La clé du champ à modifier	Oui	Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
from	Chaîne d'expression régulière à remplacer. Les caractères réguliers spéciaux tels que [et] doivent être évités en utilisant \ \ lorsque vous utilisez des guillemets doubles et avec \ lorsque vous utilisez des guillemets simples ou lorsqu'ils sont configurés à partir du AWS Management Console. Pour plus d'informations, consultez Class Pattern sur le site Web d'Oracle. Vous pouvez intégrer un motif `(...)` pour créer un groupe de capture numéroté et créer des groupes de capture `(?P<group_name>...)` nommés qui peuvent être référencés `to` sur le terrain.	Oui	Longueur maximale : 128
to	La chaîne à substituer pour chaque correspondance de `from` références arrières à des groupes de capture peut être utilisée. Utilisez le formulaire $n pour les groupes numérotés tels que `$1` et utilisez-le `${group_name}` pour les groupes nommés tels que $`{my_group}`. >	Oui	Longueur maximale : 128 Nombre maximum de références arrières : 10 Nombre maximum de références arrières dupliquées : 2

Exemple 1

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


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

La configuration du transformateur est la suivante, substituteString en utilisant parseJSON :


[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "\\[\\]",
                    "to": "value1"
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
                    "to": "xxx-xxx-xxx"            
                },
                {
                    "source": "outer_key.inner_key3",
                    "from": "cat",
                    "to": "dog"            
                }
            ]
        }
    }
]

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


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

Exemple 2

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


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

La configuration du transformateur est la suivante, substituteString en utilisant parseJSON :


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

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


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

TrimString

Le trimString processeur supprime les espaces entre le début et la fin d'une touche.

Champ	Description	Obligatoire ?	Par défaut	Limites
Avec clés	Une liste de clés à découper	Oui		Nombre maximum d'entrées : 10

Exemple

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


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

La configuration du transformateur est la suivante, trimString en utilisant parseJSON :


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

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


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

Processeurs de mutation JSON

Ajouter des clés

Utilisez le addKeys processeur pour ajouter de nouvelles paires clé-valeur à l'événement du journal.

Champ	Description	Obligatoire ?	Par défaut	Limites
entries	Tableau d'entrées. Chaque élément du tableau peut contenir des `overwriteIfExists` champs `keyvalue`, et.	Oui		Nombre maximum d'entrées : 5
clé	La clé de la nouvelle entrée à ajouter	Oui		Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
value	La valeur de la nouvelle entrée à ajouter	Oui		Longueur maximale : 256
overwriteIfExists	Si vous définissez ce paramètre sur`true`, la valeur existante est remplacée si elle existe `key` déjà dans l'événement. La valeur par défaut est `false`.	Non	false	Aucune limite

Exemple

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


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

La configuration du transformateur est la suivante, addKeys en utilisant parseJSON :


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

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


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

Supprimer les clés

Utilisez le deleteKeys processeur pour supprimer des champs d'un événement du journal. Ces champs peuvent inclure des paires clé-valeur.

Champ	Description	Obligatoire ?	Par défaut	Limites
Avec clés	La liste des clés à supprimer.	Oui	Aucune limite	Nombre maximum d'entrées : 5

Exemple

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


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

La configuration du transformateur est la suivante, deleteKeys en utilisant parseJSON :


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

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


{
  "outer_key": {}
}

Touches de déplacement

Utilisez le moveKeys processeur pour déplacer une touche d'un champ à l'autre.

Champ	Description	Obligatoire ?	Par défaut	Limites
entries	Tableau d'entrées. Chaque élément du tableau peut contenir des `overwriteIfExists` champs `sourcetarget`, et.	Oui		Nombre maximum d'entrées : 5
source	La clé pour bouger	Oui		Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
cible	La clé pour passer à	Oui		Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
overwriteIfExists	Si vous définissez ce paramètre sur`true`, la valeur existante est remplacée si elle existe `key` déjà dans l'événement. La valeur par défaut est `false`.	Non	false	Aucune limite

Exemple

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


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

La configuration du transformateur est la suivante, moveKeys en utilisant parseJSON :


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

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


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

Renommer les clés

Utilisez le renameKeys processeur pour renommer les clés dans un événement de journal.

Champ	Description	Obligatoire ?	Par défaut	Limites
entries	Tableau d'entrées. Chaque élément du tableau peut contenir des `overwriteIfExists` champs `keytarget`, et.	Oui	Aucune limite	Nombre maximum d'entrées : 5
clé	La clé pour renommer	Oui	Aucune limite	Longueur maximale : 128
cible	Le nouveau nom de clé	Oui	Aucune limite	Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
overwriteIfExists	Si vous définissez ce paramètre sur`true`, la valeur existante est remplacée si elle existe `key` déjà dans l'événement. La valeur par défaut est `false`.	Non	false	Aucune limite

Exemple

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


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

La configuration du transformateur est la suivante, renameKeys en utilisant parseJSON :


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

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


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

Copier la valeur

Utilisez le copyValue processeur pour copier des valeurs dans un journal d'événements. Vous pouvez également utiliser ce processeur pour ajouter des métadonnées aux événements du journal, en copiant les valeurs des clés de métadonnées suivantes dans le journal des événements :@logGroupName,@logGroupStream,@accountId,@regionName. Ceci est illustré dans l'exemple suivant.

Champ	Description	Obligatoire ?	Par défaut	Limites
entries	Tableau d'entrées. Chaque élément du tableau peut contenir des `overwriteIfExists` champs `sourcetarget`, et.	Oui		Nombre maximum d'entrées : 5
source	La clé à copier	Oui		Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
cible	La clé vers laquelle copier la valeur	Oui	Aucune limite	Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
overwriteIfExists	Si vous définissez ce paramètre sur`true`, la valeur existante est remplacée si elle existe `key` déjà dans l'événement. La valeur par défaut est `false`.	Non	false	Aucune limite

Exemple

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


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

La configuration du transformateur est la suivante, copyValue en utilisant parseJSON :


[
    {
        "parseJSON": {}
    },
    {
        "copyValue": {
            "entries": [
                {
                    "source": "outer_key.new_key",
                    "target": "new_key"
                },
                {
                    "source": "@logGroupName",
                    "target": "log_group_name"
                },
                {
                    "source": "@logGroupStream",
                    "target": "log_group_stream"
                },
                {
                    "source": "@accountId",
                    "target": "account_id"
                },
                {
                    "source": "@regionName",
                    "target": "region_name"
                }
            ]
        }
    }
]

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


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

Le listToMap processeur prend une liste d'objets contenant des champs clés et les convertit en une carte de clés cibles.

Champ	Description	Obligatoire ?	Par défaut	Limites
source	La clé ProcessingEvent avec une liste d'objets qui seront convertis en carte	Oui		Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
clé	La clé des champs à extraire sous forme de clés dans la carte générée	Oui		Longueur maximale : 128
Clé de valeur	Si cela est spécifié, les valeurs que vous spécifiez dans ce paramètre seront extraites des `source` objets et insérées dans les valeurs de la carte générée. Dans le cas contraire, les objets originaux de la liste source seront placés dans les valeurs de la carte générée.	Non		Longueur maximale : 128
cible	La clé du champ qui contiendra la carte générée	Non	Nœud racine	Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
flatten	Valeur booléenne indiquant si la liste sera aplatie en éléments individuels ou si les valeurs de la carte générée seront des listes. Par défaut, les valeurs des clés correspondantes seront représentées dans un tableau. Définissez `flatten` sur `true` pour convertir le tableau en une valeur unique basée sur la valeur de`flattenedElement`.	Non	false
Élément aplati	Si vous définissez `flatten` sur`true`, `flattenedElement` utilisez-le pour spécifier quel élément, `first` ou`last`, à conserver.	Obligatoire lorsque `flatten` le paramètre est défini sur `true`		La valeur ne peut être que `first` ou `last`

Exemple

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


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

Transformateur pour le cas d'utilisation 1 : flatten est false


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

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


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

Transformateur pour le cas d'utilisation 2 : flatten est true et flattenedElement est first


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

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


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

Transformateur pour le cas d'utilisation 3 : flatten est true et flattenedElement est last


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

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


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

Processeurs de conversion de types de données

Type de convertisseur

Utilisez le typeConverter processeur pour convertir un type de valeur associé à la clé spécifiée en type spécifié. Il s'agit d'un processeur de casting qui modifie les types des champs spécifiés. Les valeurs peuvent être converties dans l'un des types de données suivants :integer,double, string et. boolean

Champ Description Obligatoire ? Par défaut Limites

Champ	Description	Obligatoire ?	Limites
entries	Tableau d'entrées. Chaque élément du tableau doit contenir `key` des `type` champs.	Oui	Nombre maximum d'entrées : 10
clé	La clé dont la valeur doit être convertie en un autre type	Oui	Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
type	Le type vers lequel effectuer la conversion. Les valeurs valides sont `integerdouble`, `string` et`boolean`.	Oui

entries

Tableau d'entrées. Chaque élément du tableau doit contenir key des type champs.

Oui

Nombre maximum d'entrées : 10

clé

La clé dont la valeur doit être convertie en un autre type

Oui

Longueur maximale : 128

Profondeur maximale des touches imbriquées : 3

type

Le type vers lequel effectuer la conversion. Les valeurs valides sont integerdouble, string etboolean.

Oui

Exemple

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


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

La configuration du transformateur est la suivante, typeConverter en utilisant parseJSON :


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

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


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

Convertisseur Date/Heure

Utilisez le datetimeConverter processeur pour convertir une chaîne de date/heure dans un format que vous spécifiez.

Champ	Description	Obligatoire ?	Par défaut	Limites
source	La clé à laquelle appliquer la conversion de date.	Oui		Nombre maximum d'entrées : 10
Motifs de match	Une liste de modèles à comparer au `source` champ	Oui		Nombre maximum d'entrées : 5
cible	Le champ JSON dans lequel stocker le résultat.	Oui		Longueur maximale : 128 Profondeur maximale des touches imbriquées : 3
Format cible	Format de date/heure à utiliser pour les données converties dans le champ cible.	Non	`yyyy-MM-dd'T'HH:mm:ss.SSS'Z`	Longueur maximale : 64
Fuseau horaire de la source	Fuseau horaire du champ source. Pour obtenir la liste des valeurs possibles, consultez la section Identifiants et décalages de zone pris en charge par Java.	Non	UTC	Longueur minimale : 1
Fuseau horaire cible	Fuseau horaire du champ cible. Pour obtenir la liste des valeurs possibles, consultez la section Identifiants et décalages de zone pris en charge par Java.	Non	UTC	Longueur minimale : 1
locale	Les paramètres régionaux du champ source. Pour une liste des valeurs possibles, consultez la méthode locale getAvailableLocales () en Java avec des exemples.	Oui		Longueur minimale : 1

Exemple

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


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

La configuration du transformateur est la suivante, dateTimeConverter en utilisant parseJSON :


[
    {
        "parseJSON": {}
    },
    {
        "dateTimeConverter": {
            "source": "german_datetime",
            "target": "target_1",
            "locale": "de",
            "matchPatterns": ["EEEE dd. MMMM yyyy HH:mm:ss"],
            "sourceTimezone": "Europe/Berlin",
            "targetTimezone": "America/New_York",
            "targetFormat": "yyyy-MM-dd'T'HH:mm:ss z"
        }
    }
]

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


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Supprimer un log-group-level transformateur

Métriques de transformation et erreurs