Syntaxe d'expression pour le traitement conditionnel

CloudWatch les processeurs de pipelines qui prennent en charge le traitement conditionnel acceptent un when paramètre contenant une expression. Lorsque l'expression prend la valeur true, le processeur ou l'entrée s'exécute. Les expressions utilisent la notation par points (.) pour accéder aux champs imbriqués. Par exemple, user.role accède au role champ situé à l'intérieur de l'userobjet. Pour plus de détails sur les processeurs qui prennent en charge le traitement conditionnel et leurs paramètres spécifiques, consultezCloudWatch processeurs de pipelines. Pour des exemples de configuration, consultezCas d'utilisation courants des processeurs.

Note

Le traitement conditionnel s'applique uniquement aux pipelines de journalisation. Les pipelines de métriques ne prennent pas en charge when ce paramètre.

Processor-level et conditions d'entrée de gamme

Vous pouvez appliquer une when condition à deux niveaux, en fonction du processeur.

Processor-level when(niveau extérieur)

A when placé au niveau supérieur de la configuration du processeur. Si la valeur de l'expression est fausse, l'intégralité du processeur est ignorée et aucune opération ne s'exécute à l'intérieur de celui-ci. Tous les processeurs qui prennent en charge le traitement conditionnel prennent en charge ce niveau.

Exemple Processor-level condition — ignorer l'intégralité du processeur

Le delete_entries processeur suivant ne fonctionne que lorsque l'environnement est en production ou en phase de test. Si la condition est fausse, aucune clé n'est supprimée.

processor:
  - delete_entries:
      with_keys: ["password", "api_key", "ssn"]
      when: "environment in {'prod', 'staging'}"

Entry-level when(dans chaque entrée)

A when placé à l'intérieur d'une entrée individuelle du entries tableau. Chaque entrée est évaluée indépendamment : si l'expression est fausse, seule cette entrée spécifique est ignorée tandis que les autres entrées du même processeur s'exécutent toujours. Seuls les processeurs dotés d'une entries matrice prennent en charge ce niveau (par exemple add_entries copy_valuesrename_keys,move_keys,extract_value, etsubstitute_string).

Exemple Entry-level condition — ignorer les entrées individuelles

Le add_entries processeur suivant ajoute différentes clés en fonction de l'état de chaque entrée. La première entrée n'est ajoutée que severity lorsque le niveau de journalisation est ERROR. La deuxième entrée est toujours ajoutée processed car elle ne comporte aucune condition.

processor:
  - add_entries:
      entries:
        - key: "severity"
          value: "high"
          when: "log.level == 'ERROR'"
        - key: "processed"
          value: "true"

Les processeurs qui prennent en charge les deux niveaux peuvent les utiliser ensemble. Lorsque les deux sont spécifiés, la condition au niveau du processeur est d'abord évaluée. S'il est faux, l'ensemble du processeur est ignoré et aucune condition d'entrée de gamme n'est évaluée.

Exemple Les deux niveaux combinés

Le niveau du processeur when garantit que l'ensemble du processeur ne fonctionne que pour le trafic de production. Dans ce cadre, chaque entrée possède sa propre condition pour contrôler quelle clé est ajoutée.

processor:
  - add_entries:
      when: "environment == 'prod'"
      entries:
        - key: "alert_level"
          value: "critical"
          when: "log.level == 'ERROR'"
        - key: "alert_level"
          value: "warning"
          when: "log.level == 'WARN'"

Pour consulter un tableau indiquant quels processeurs prennent en charge quel niveau, consultez la Support de traitement conditionnel section ci-dessous.

Fallback avec when_else

Les processeurs qui prennent en charge les conditions d'entrée de gamme le prennent également en charge. when_else Une entrée avec when_else agit comme une solution de repli : elle ne s'exécute que lorsqu'aucune des autres when conditions du même processeur ne correspond. La valeur d'expression fournie pour when_else identifier l'ensemble de when conditions à prendre en compte, mais l'entrée elle-même s'exécute uniquement en fonction du fait que ces conditions ont toutes été évaluées comme fausses. Il n'y a pas de contrôle de négation explicite : l'entrée est simplement exécutée lorsqu'aucune autre ne when correspond.

Exemple Entrée de secours avec when_else

La première entrée est exécutée lorsque le niveau de journalisation est ERROR. La deuxième entrée n'est utilisée when_else et exécutée que lorsque la when condition de la première entrée ne correspond pas (c'est-à-dire que le niveau de journalisation est autre que ERROR).

processor:
  - add_entries:
      entries:
        - key: "alert_level"
          value: "critical"
          when: "log.level == 'ERROR'"
        - key: "alert_level"
          value: "info"
          when_else: "log.level == 'ERROR'"

Support de traitement conditionnel

Le tableau suivant indique quels processeurs prennent en charge le traitement conditionnel et à quel niveau.

Processeur	Support conditionnel	Niveau
ajouter_entrées	Oui	Processeur et entrée
copy_values	Oui	Processeur et entrée
supprime_entrées	Oui	Processeur
move_keys	Oui	Processeur et entrée
flatten	Oui	Processeur
chaîne_minuscules	Oui	Processeur
chaîne_majuscules	Oui	Processeur
trim_string	Oui	Processeur
chaîne de substitution	Oui	Processeur et entrée
tronquer	Oui	Processeur
valeur_d'extrait	Oui	Processeur et entrée
convert_entry_type	Oui	Processeur
date	Oui	Processeur
disséquer	Oui	Processeur
liste_à_carte	Oui	Processeur
renomme_keys	Oui	Processeur et entrée
select_entries	Oui	Processeur
translate	Oui	Processeur
grok	Oui	Processeur
drop_events	Oui	Processeur (obligatoire)
OCSF, CSV, JSON, WAF KeyValue, Postgres, VPC CloudFront, Route53	Non	—

Opérateurs

Le tableau suivant répertorie les opérateurs pris en charge.

Catégorie	Opérateurs	Exemple
Relationnel	<, <=, >, >=	status_code >= 200 and status_code < 300
Égalité	==, !=	log.level == "ERROR"
Conditionnel	and, or, not	log.level == "ERROR" or log.level == "FATAL"
Arithmétique	+, -, *, /	response_time * 1000 > 5000
Abonnement fixe	in, not in	environment in {"prod", "staging", "preprod"}
Correspondance Regex	=~, !~	message =~ "^ERROR.*timeout"

Fonctions

length(value)

Renvoie la longueur d'une chaîne ou d'un tableau. Exemple : length(message) > 100

contains(value, search)

Vérifie si une chaîne contient une sous-chaîne ou si un tableau contient un élément. Exemple : contains(message, "error")

startsWith(field, prefix)

Vérifie si une chaîne commence par un préfixe spécifié. Exemple : startsWith(message, "ERROR")

Exemples d'expressions

log.level == "ERROR"
status_code >= 200 and status_code < 300
environment in {"prod", "staging", "preprod"}
message =~ "^ERROR.*timeout"
user.role == "admin" and user.permissions.write == true
length(message) > 100 and contains(message, "error")
(log.level == "ERROR" or log.level == "FATAL") and environment == "prod"

Limitations

• La longueur maximale de l'expression est de 256 caractères.

• Les processeurs d'analyse (à l'exception de Grok) ne prennent pas en charge le traitement conditionnel. Cela inclut les analyseurs JSON, CSV KeyValue, WAF, Postgres, VPC CloudFront, Route53 et OCSF.

• Si le processeur Grok est utilisé comme analyseur (premier processeur) dans un pipeline et que sa when condition est évaluée à false, le pipeline entier ne s'exécute pas pour cet événement de journal.