Syntaxe d'expression pour le traitement conditionnel - Amazon CloudWatch
Conditions au niveau du processeur et au niveau de l'entrée de gammeAssistance au traitement conditionnelOpérateursFonctionsExemples d'expressionsLimitations

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.

Syntaxe d'expression pour le traitement conditionnel

CloudWatch les processeurs de pipeline qui prennent en charge le traitement conditionnel acceptent un when paramètre contenant une expression. Lorsque l'expression est vraie, 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 pipelines et processeurs. Pour des exemples de configuration, consultezCas d'utilisation courants des processeurs.

Conditions au niveau du processeur et au niveau de l'entrée de gamme

Il existe deux niveaux auxquels vous pouvez appliquer une when condition, selon le processeur.

Niveau processeur when (niveau externe)

A when placé au niveau supérieur de la configuration du processeur. Si l'expression est fausse, l'ensemble du processeur est ignoré et aucune opération n'est exécutée au sein de celui-ci. Tous les processeurs qui prennent en charge le traitement conditionnel prennent en charge ce niveau.

ExempleÉtat au niveau du processeur : ignorer l'intégralité du processeur

Le delete_entries processeur suivant ne s'exécute que lorsque l'environnement est en production ou en phase de préparation. Si la condition est fausse, aucune des clés n'est supprimée.

processor:
  - delete_entries:
      with_keys: ["password", "api_key", "ssn"]
      when: "environment in {'prod', 'staging'}"
Niveau d'entrée 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 continuent de s'exécuter. Seuls les processeurs dotés d'une entries baie prennent en charge ce niveau (par exemple add_entries copy_valuesrename_keys,move_keys,extract_value,, etsubstitute_string).

Exemple Condition d'entrée de gamme : 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 du journal est ERROR. La deuxième entrée est toujours ajoutée processed car elle ne contient aucune condition.

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

Les processeurs compatibles avec les deux niveaux peuvent les utiliser ensemble. Lorsque les deux sont spécifiés, la condition au niveau du processeur est évaluée en premier. Si elle est fausse, 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 un tableau indiquant quels processeurs prennent en charge quel niveau, consultez la Assistance au traitement conditionnel section ci-dessous.

Fallback avec when_else

Les processeurs compatibles avec les conditions d'entrée de gamme sont également compatibles. when_else Une entrée avec when_else agit comme une solution de secours : elle ne s'exécute que lorsqu'aucune des autres when conditions du même processeur ne correspond. La valeur d'expression fournie à when_else identifie l'ensemble de when conditions à prendre en compte, mais l'entrée elle-même s'exécute uniquement en fonction de la valeur fausse de ces conditions. 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 du journal est ERROR. La deuxième entrée est utilisée when_else et exécutée uniquement lorsque la when condition de la première entrée ne correspond pas (c'est-à-dire que le niveau du journal est autre chose qu'ERROR).

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

Assistance au traitement conditionnel

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

Support conditionnel du processeur
Processeur Soutien conditionnel Niveau
ajouter_entréesOuiProcesseur et entrée
copy_valuesOuiProcesseur et entrée
supprimer_entréesOuiProcesseur
move_keysOuiProcesseur et entrée
flattenOuiProcesseur
chaîne_minusculeOuiProcesseur
chaîne_majusculeOuiProcesseur
trim_stringOuiProcesseur
chaîne_de substitutionOuiProcesseur et entrée
tronquerOuiProcesseur
valeur_d'extractionOuiProcesseur et entrée
convert_entry_typeOuiProcesseur
dateOuiProcesseur
disséquerOuiProcesseur
liste_to_carteOuiProcesseur
renommer les clésOuiProcesseur et entrée
select_entréesOuiProcesseur
translateOuiProcesseur
grokOuiProcesseur
drop_eventsOuiProcesseur (obligatoire)
OCSF, CSV, JSON, WAF KeyValue, Postgres, CloudFront VPC, Route 53Non—

Opérateurs

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
Définir l'adhésion 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, CloudFront VPC, Route53 et OCSF.

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