Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Sintassi delle espressioni per l'elaborazione condizionale
<a name="conditional-processing"></a>

CloudWatch i processori di pipeline che supportano l'elaborazione condizionale accettano un parametro contenente un'`when`espressione. Quando l'espressione restituisce true, il processore o la voce viene eseguito. Le espressioni utilizzano la notazione a punti (`.`) per l'accesso ai campi annidati. Ad esempio, `user.role` accede al `role` campo all'interno dell'oggetto. `user` Per ulteriori dettagli sui processori che supportano l'elaborazione condizionale e i relativi parametri specifici, vedere. [CloudWatch processori di pipeline](pipeline-processors.md) Per esempi di configurazione, vedere[Casi d'uso comuni del processore](processor-examples.md).

## Condizioni a livello di processore e di livello base
<a name="conditional-levels"></a>

Esistono due livelli ai quali è possibile applicare una `when` condizione, a seconda del processore.

A livello di processore `when` (livello esterno)  
A `when` si trova al livello più alto della configurazione del processore. Se l'espressione restituisce false, l'intero processore viene ignorato e non viene eseguita alcuna operazione al suo interno. Tutti i processori che supportano l'elaborazione condizionale supportano questo livello.  

**Example Condizione a livello di processore: salta l'intero processore**  
Il seguente `delete_entries` processore funziona solo quando l'ambiente è di produzione o di gestione temporanea. Se la condizione è falsa, nessuna delle chiavi viene eliminata.  

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

Livello base `when` (all'interno di ogni voce)  
A `when` inserito all'interno di una singola voce dell'`entries`array. Ogni voce viene valutata indipendentemente: se l'espressione è falsa, solo quella voce specifica viene saltata mentre le altre voci dello stesso processore continuano a essere eseguite. Solo i processori con un `entries` array supportano questo livello (ad esempio`add_entries`,`copy_values`,`rename_keys`, `move_keys``extract_value`, e`substitute_string`).  

**Example Condizione di livello base: salta le singole voci**  
Il seguente `add_entries` processore aggiunge chiavi diverse a seconda della condizione di ciascuna voce. La prima voce viene aggiunta solo `severity` quando il livello di registro è ERROR. La seconda voce viene sempre aggiunta `processed` perché non presenta alcuna condizione.  

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

I processori che supportano entrambi i livelli possono utilizzarli insieme. Quando vengono specificati entrambi, la condizione a livello di processore viene valutata per prima. Se è falsa, l'intero processore viene ignorato e non viene valutata alcuna condizione di livello base.

**Example Entrambi i livelli combinati**  
Il livello di processore `when` garantisce che l'intero processore funzioni solo per il traffico di produzione. All'interno di ciò, ogni voce ha una propria condizione per controllare quale chiave viene aggiunta.  

```
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'"
```

Per una tabella che mostra quali processori supportano un determinato livello, consultate la [Supporto all'elaborazione condizionale](#conditional-support) sezione seguente.

**Fallback con `when_else`**  
Supportano anche i processori che supportano le condizioni entry-level. `when_else` Una voce con `when_else` funge da fallback: viene eseguita solo quando nessuna delle altre `when` condizioni dello stesso processore soddisfa. Il valore dell'espressione fornito `when_else` identifica l'insieme di `when` condizioni da considerare, ma la voce stessa viene eseguita esclusivamente in base al fatto che tutte le condizioni siano state valutate come false. Non esiste un controllo di negazione esplicito: la voce viene semplicemente eseguita quando nessun'altra corrisponde. `when`

**Example Voce di fallback con when\$1else**  
La prima voce viene eseguita quando il livello di registro è ERROR. La seconda voce viene utilizzata `when_else` ed eseguita solo quando la `when` condizione della prima voce non corrisponde (ad esempio, il livello di registro è diverso da ERROR).  

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

## Supporto all'elaborazione condizionale
<a name="conditional-support"></a>

La tabella seguente mostra quali processori supportano l'elaborazione condizionale e a quale livello.


**Supporto condizionale del processore**  

| Processore | Supporto condizionale | Livello | 
| --- | --- | --- | 
| add\$1entry | Sì | Processore e ingresso | 
| copy\$1values | Sì | Processore e ingresso | 
| delete\$1entries | Sì | Processore | 
| move\$1keys | Sì | Processore e ingresso | 
| flatten | Sì | Processore | 
| lowercase\$1string | Sì | Processore | 
| stringa maiuscola | Sì | Processore | 
| trim\$1string | Sì | Processore | 
| sostituto\$1stringa | Sì | Processore e ingresso | 
| troncare | Sì | Processore | 
| valore\$1estrazione | Sì | Processore e ingresso | 
| convert\$1entry\$1type | Sì | Processore | 
| data | Sì | Processore | 
| sezionare | Sì | Processore | 
| lista\$1su\$1mappa | Sì | Processore | 
| rename\$1keys | Sì | Processore e ingresso | 
| select\$1entry | Sì | Processore | 
| translate | Sì | Processore | 
| gruppo | Sì | Processore | 
| drop\$1events | Sì | Processore (richiesto) | 
| OCSF, CSV, JSON, WAF, Postgres KeyValue, VPC, Route 53 CloudFront | No | — | 

## Operatori
<a name="expression-operators"></a>


**Operatori supportati**  

| Categoria | Operatori | Esempio | 
| --- | --- | --- | 
| Relazionale | <, <=, >, >= | status\$1code >= 200 and status\$1code < 300 | 
| Parità | ==, \$1= | log.level == "ERROR" | 
| Condizionale | and, or, not | log.level == "ERROR" or log.level == "FATAL" | 
| Aritmetica | \$1, -, \$1, / | response\$1time \$1 1000 > 5000 | 
| Imposta l'iscrizione | in, not in | environment in \$1"prod", "staging", "preprod"\$1 | 
| Corrispondenza Regex | =\$1, \$1\$1 | message =\$1 "^ERROR.\$1timeout" | 

## Funzioni
<a name="expression-functions"></a>

`length(value)`  
Restituisce la lunghezza di una stringa o di un array. Ad esempio: `length(message) > 100`

`contains(value, search)`  
Verifica se una stringa contiene una sottostringa o un array contiene un elemento. Ad esempio: `contains(message, "error")`

`startsWith(field, prefix)`  
Verifica se una stringa inizia con un prefisso specificato. Ad esempio: `startsWith(message, "ERROR")`

## Esempi di espressioni
<a name="expression-examples"></a>

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

## Limitazioni
<a name="expression-limitations"></a>
+ La lunghezza massima dell'espressione è di 256 caratteri.
+ I processori parser (eccetto Grok) non supportano l'elaborazione condizionale. Ciò include i parser JSON, CSV, WAF KeyValue, Postgres, VPC CloudFront, Route53 e OCSF.
+ Se il processore Grok viene utilizzato come parser (primo processore) in una pipeline e la sua `when` condizione risulta falsa, l'intera pipeline non viene eseguita per quell'evento di registro.