Syntaxe EQL prise en charge pour les requêtes avancées

Aide sur la syntaxe

Le volet d'aide sur la syntaxe sous Aurora Focus > Recherche avancée répertorie les classes d'évènements Aurora Focus disponibles et leurs artefacts, types, catégories et sous-catégories associés. À mesure de la saisie, des options de syntaxe et des messages de validation s'affichent pour vous aider à créer votre requête.

Format de requête EQL

Les requêtes EQL Aurora Focus utilisent le format suivant pour une requête de base :

CODE 
event class where event/artifact.facet == value

Une requête recherche les événements liés à des artefacts. Vous devez donc utiliser la classe d'événements appropriée dans votre requête.

La clause WHERE peut filtrer les résultats en fonction des valeurs event.type, event.category, event.subcategory ou artifact.facet.

Vous pouvez utiliser ou pour combiner plusieurs clauses de filtre.

Faire correspondre n'importe quelle classe d'événement

Vous pouvez utiliser n'importe lequel pour la classe d'événements, qui correspond à toutes les classes d'événements disponibles.

Échapper une classe d'événements

Pour échapper aux classes d'événements qui contiennent un caractère spécial (par exemple, un tiret ou un point), contiennent un espace ou commencent par un chiffre, utilisez des guillemets (") ou trois guillemets (""").

Échapper un nom de champ

Pour échapper des noms de champ contenant un trait d'union, un espace ou commençant par un chiffre, utilisez les coches arrière (`). Utilisez des coches doubles (``) pour échapper tout coche (`) dans le nom du champ.

Échapper une valeur

Si vous utilisez un caractère spécial dans une valeur, y compris un guillemet ou une barre oblique inverse, elle doit être précédée d'une barre oblique inverse (par exemple, \” pour un guillemet et \\ pour une barre oblique inverse).

Conditions

Une condition consiste en un ou plusieurs critères auxquels un événement doit correspondre. Vous pouvez spécifier et combiner des critères avec les opérateurs décrits dans les sections suivantes.

Opérateurs de comparaison

Opérateur

Description

<

Cet opérateur renvoie vrai si la valeur à gauche de l'opérateur est inférieure à la valeur à droite. Sinon, il renvoie faux.

<=

Cet opérateur renvoie vrai si la valeur à gauche de l'opérateur est inférieure ou égale à la valeur à droite. Sinon, il renvoie faux.

==

Cet opérateur renvoie vrai si les valeurs à gauche et à droite de l'opérateur sont égales. Sinon, il renvoie faux. Les caractères génériques ne sont pas pris en charge.

:

Cet opérateur renvoie vrai si les chaînes à gauche et à droite de l'opérateur sont égales. Sinon, il renvoie faux. Peut être utilisé pour comparer des chaînes uniquement.

!=

Cet opérateur renvoie la vrai si les valeurs à gauche et à droite de l'opérateur ne sont pas égales. Sinon, il renvoie faux. Les caractères génériques ne sont pas pris en charge. Notez que les valeurs NULL sont également filtrées à partir des résultats (vous pouvez utiliser == NULL pour afficher les résultats NULL).

>=

Cet opérateur renvoie vrai si la valeur à gauche de l'opérateur est supérieure ou égale à la valeur à droite. Sinon, il renvoie faux. Lors de la comparaison de chaînes, l'opérateur utilise un ordre lexicographique sensible à la casse.

>

Cet opérateur renvoie vrai si la valeur à gauche de l'opérateur est supérieure à la valeur à droite. Sinon, il renvoie faux. Lors de la comparaison de chaînes, l'opérateur utilise un ordre lexicographique sensible à la casse.

= n'est pas pris en charge en tant qu'opérateur égal. Utilisez plutôt == ou :

Mots-clés de comparaison de modèles

Opérateur

Description

like

Cet opérateur renvoie vrai si la chaîne à gauche du mot-clé correspond à la chaîne à droite (sensible à la casse). Il prend en charge les recherches de liste (voir les opérateurs de recherche ci-dessous) et peut être utilisé pour comparer des chaînes uniquement. Pour une correspondance non sensible à la casse, utilisez like~.

regex

Cet opérateur renvoie vrai si la chaîne à gauche du mot-clé correspond à une expression régulière à droite (reportez-vous à la section Syntaxe d'expression régulière). Il prend en charge les recherches de liste et peut être utilisé pour comparer des chaînes uniquement. Pour une correspondance non sensible à la casse, utilisez regex~.
CODE 
my_field like  "VALUE*"         // case-sensitive wildcard matching
my_field like~ "value*"         // case-insensitive wildcard matching

my_field regex  "VALUE[^Z].?"   // case-sensitive regex matching
my_field regex~ "value[^z].?"   // case-insensitive regex matching

Limites des comparaisons

Vous ne pouvez pas les comparer en chaîne. Utilisez plutôt un opérateur logique entre les comparaisons (reportez-vous à la section opérateurs logiques ci-dessous).

Par exemple, foo < bar <= baz n'est pas prise en charge, alors que foo < bar and bar <= baz l'est.

Vous ne pouvez pas comparer un champ à un autre, même si les champs sont modifiés à l'aide d'une fonction.

La requête suivante n'est pas valide car elle compare la valeur du champ process.parent.name au champ process.name :

CODE 
process where process.parent.name == "foo" and process.parent.name == process.name

La requête suivante est valide car elle compare les champs process.parent.name et process.name aux valeurs statiques :

CODE 
process where process.parent.name == "foo" and process.name == "foo"

Opérateurs logiques

Opérateur

Description

and

Cet opérateur renvoie vrai uniquement si la condition à gauche et à droite renvoient toutes les deux la valeur vrai. Sinon, il renvoie faux.

ou

Cet opérateur renvoie vrai si l'une des conditions à gauche ou à droite est vraie. Sinon, il renvoie faux.

non

Cet opérateur renvoie vrai si la condition à droite est faux.

Opérateurs de recherche

Opérateur

Description

in

Cet opérateur renvoie vrai si la valeur figure dans la liste fournie (sensible à la casse). Pour une correspondance non sensible à la casse, utilisez in~.

not in

Cet opérateur renvoie vrai si la valeur ne figure pas dans la liste fournie (sensible à la casse). Pour une correspondance non sensible à la casse, utilisez not in~.

:

Cet opérateur renvoie vrai si la chaîne est contenue dans la liste fournie. Il ne peut être utilisé que pour comparer des chaînes.

like

Cet opérateur renvoie vrai si la chaîne correspond à une chaîne de la liste fournie (sensible à la casse). Il ne peut être utilisé que pour comparer des chaînes. Pour une correspondance non sensible à la casse, utilisez like~.

regex

Cet opérateur renvoie vrai si la chaîne correspond à un modèle d'expression régulière dans la liste fournie (reportez-vous à la section Syntaxe des expressions régulières). Il ne peut être utilisé que pour comparer des chaînes. Pour une correspondance non sensible à la casse, utilisez regex~.
CODE 
my_field in ("Value-1", "VALUE2", "VAL3")                 // case-sensitive
my_field in~ ("value-1", "value2", "val3")                // case-insensitive

my_field not in ("Value-1", "VALUE2", "VAL3")             // case-sensitive
my_field not in~ ("value-1", "value2", "val3")            // case-insensitive

my_field : ("value-1", "value2", "val3")                  // case-insensitive

my_field like  ("Value-*", "VALUE2", "VAL?")              // case-sensitive
my_field like~ ("value-*", "value2", "val?")              // case-insensitive

my_field regex  ("[vV]alue-[0-9]", "VALUE[^2].?", "VAL3") // case-sensitive
my_field regex~  ("value-[0-9]", "value[^2].?", "val3")   // case-insensitive

Correspond à n'importe quelle condition

Utilisez la condition where true pour mettre en correspondance les événements uniquement sur la catégorie d'événement. Par exemple, la requête suivante correspond à n'importe quel événement de fichier :

CODE 
file where true

Pour faire correspondre n'importe quel événement, vous pouvez combiner le mot-clé any avec la condition where true :

CODE 
any where true

Exemples d'interrogations

Reportez-vous à la section Exemples de requêtes EQL Aurora Focus.