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'`user`objet. Pour plus de détails sur les processeurs qui prennent en charge le traitement conditionnel et leurs paramètres spécifiques, consultez[CloudWatch pipelines et processeurs](pipeline-processors.md). Pour des exemples de configuration, consultez[Cas d'utilisation courants des processeurs](processor-examples.md).
## 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.
**Example É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_values``rename_keys`,`move_keys`,`extract_value`,, et`substitute_string`).
**Example 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.
**Example 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](#conditional-support) 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.
**Example Entrée de secours avec when\$1else**
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\$1entrées | Oui | Processeur et entrée |
| copy\$1values | Oui | Processeur et entrée |
| supprimer\$1entrées | Oui | Processeur |
| move\$1keys | Oui | Processeur et entrée |
| flatten | Oui | Processeur |
| chaîne\$1minuscule | Oui | Processeur |
| chaîne\$1majuscule | Oui | Processeur |
| trim\$1string | Oui | Processeur |
| chaîne\$1de substitution | Oui | Processeur et entrée |
| tronquer | Oui | Processeur |
| valeur\$1d'extraction | Oui | Processeur et entrée |
| convert\$1entry\$1type | Oui | Processeur |
| date | Oui | Processeur |
| disséquer | Oui | Processeur |
| liste\$1to\$1carte | Oui | Processeur |
| renommer les clés | Oui | Processeur et entrée |
| select\$1entrées | Oui | Processeur |
| translate | Oui | Processeur |
| grok | Oui | Processeur |
| drop\$1events | Oui | Processeur (obligatoire) |
| OCSF, CSV, JSON, WAF KeyValue, Postgres, CloudFront VPC, Route 53 | Non | — |
## Opérateurs
**Opérateurs pris en charge**
| Catégorie | Opérateurs | Exemple |
| --- | --- | --- |
| Relationnel | <, <=, >, >= | status\$1code >= 200 and status\$1code < 300 |
| Égalité | ==, \$1= | log.level == "ERROR" |
| Conditionnel | and, or, not | log.level == "ERROR" or log.level == "FATAL" |
| Arithmétique | \$1, -, \$1, / | response\$1time \$1 1000 > 5000 |
| Définir l'adhésion | in, not in | environment in \$1"prod", "staging", "preprod"\$1 |
| Correspondance Regex | =\$1, \$1\$1 | message =\$1 "^ERROR.\$1timeout" |
## 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.