# Sintaxis de expresiones para el procesamiento condicional
Los procesadores de canalizaciones de CloudWatch que admiten el procesamiento condicional aceptan un parámetro `when` que contiene una expresión Cuando la expresión se evalúa como verdadera, el procesador o la entrada se pone en marcha. Las expresiones utilizan la notación de puntos (`.`) para acceder a los campos anidados. Por ejemplo, `user.role` accede al campo `role` situado dentro del objeto `user`. Para obtener más información sobre los procesadores que admiten el procesamiento condicional y sus parámetros específicos, consulte [Procesadores de canalizaciones de CloudWatch](pipeline-processors.md). Para obtener ejemplos de configuración de , consulte [Casos de uso de procesadores comunes](processor-examples.md).
## Condiciones de procesador y de entrada
Hay dos niveles en los que se puede aplicar una condición `when`, según el procesador.
`when` a nivel de procesador (nivel externo)
Un `when` colocado en el nivel superior de la configuración del procesador. Si la expresión se evalúa como falsa, se omite el procesador completo y no se pone en marcha ninguna operación dentro de él. Todos los procesadores que admiten el procesamiento condicional admiten este nivel.
**Example Condición a nivel de procesador: omitir el procesador completo**
El siguiente procesador `delete_entries` solo se pone en marcha cuando el entorno es de producción o de prueba Si la condición es falsa, no se elimina ninguna clave.
```
processor:
- delete_entries:
with_keys: ["password", "api_key", "ssn"]
when: "environment in {'prod', 'staging'}"
```
`when` a nivel de entrada (dentro de cada entrada)
Un `when` colocado dentro de una entrada individual en la matriz `entries`. Cada entrada se evalúa de forma independiente; si la expresión es falsa, solo se omite esa entrada específica, mientras que las demás entradas del mismo procesador continúan poniéndose en marcha. Solo los procesadores con una matriz `entries` admiten este nivel (como `add_entries`, `copy_values`, `rename_keys`, `move_keys`, `extract_value` y `substitute_string`).
**Example Condición a nivel de entrada: omitir entradas individuales**
El siguiente procesador `add_entries` agrega claves diferentes según el estado de cada entrada. La primera entrada solo agrega `severity` cuando el nivel de registro es ERROR. La segunda entrada siempre agrega `processed` porque no tiene ninguna condición.
```
processor:
- add_entries:
entries:
- key: "severity"
value: "high"
when: "log.level == 'ERROR'"
- key: "processed"
value: "true"
```
Los procesadores que admiten ambos niveles pueden utilizarlos de forma conjunta. Cuando se especifican ambos, primero se evalúa la condición a nivel de procesador. Si es falsa, se omite todo el procesador y no se evalúa ninguna condición de entrada.
**Example Ambos niveles combinados**
El `when` a nivel de procesador garantiza que el procesador completo solo se ponga en marcha para el tráfico de producción Dentro de este, cada entrada tiene su propia condición para controlar qué clave se agrega.
```
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'"
```
Para ver una tabla que muestra qué procesadores admiten cada nivel, consulte la sección [Compatibilidad con el procesamiento condicional](#conditional-support) siguiente.
**Alternativa con `when_else`**
Los procesadores que admiten condiciones a nivel de entrada también admiten `when_else`. Una entrada con `when_else` actúa como alternativa: se pone en marcha solo cuando ninguna de las otras condiciones `when` del mismo procesador se cumplió. El valor de expresión proporcionado a `when_else` identifica qué conjunto de condiciones `when` se debe considerar, pero la entrada en sí se pone en marcha únicamente si todas esas condiciones se evaluaron como falsas No hay ninguna comprobación de negación explícita: la entrada simplemente se pone en marcha cuando ningún otro `when` coincidió.
**Example Entrada alternativa con when\$1else**
La primera entrada se pone en marcha cuando el nivel de registro es ERROR. La segunda entrada usa `when_else` y se pone en marcha solo cuando la condición `when` de la primera entrada no coincide (es decir, el nivel de registro no es ERROR).
```
processor:
- add_entries:
entries:
- key: "alert_level"
value: "critical"
when: "log.level == 'ERROR'"
- key: "alert_level"
value: "info"
when_else: "log.level == 'ERROR'"
```
## Compatibilidad con el procesamiento condicional
La siguiente tabla muestra qué procesadores admiten el procesamiento condicional y en qué nivel.
**Compatibilidad condicional del procesador**
| Procesador | Compatibilidad condicional | Nivel |
| --- | --- | --- |
| add\$1entries | Sí | Procesador y entrada |
| copy\$1values | Sí | Procesador y entrada |
| delete\$1entries | Sí | Procesador |
| move\$1keys | Sí | Procesador y entrada |
| flatten | Sí | Procesador |
| lowercase\$1string | Sí | Procesador |
| uppercase\$1string | Sí | Procesador |
| trim\$1string | Sí | Procesador |
| substitute\$1string | Sí | Procesador y entrada |
| truncate | Sí | Procesador |
| extract\$1value | Sí | Procesador y entrada |
| convert\$1entry\$1type | Sí | Procesador |
| date | Sí | Procesador |
| dissect | Sí | Procesador |
| list\$1to\$1map | Sí | Procesador |
| rename\$1keys | Sí | Procesador y entrada |
| select\$1entries | Sí | Procesador |
| translate | Sí | Procesador |
| grok | Sí | Procesador |
| drop\$1events | Sí | Procesador (obligatorio) |
| OCSF, CSV, JSON, KeyValue, WAF, Postgres, CloudFront, VPC, Route53 | No | — |
## Operadores
**Operadores admitidos**
| Categoría | Operadores | Ejemplo |
| --- | --- | --- |
| Relacional | <, <=, >, >= | status\$1code >= 200 and status\$1code < 300 |
| Igualdad | ==, \$1= | log.level == "ERROR" |
| Condicional | and, or, not | log.level == "ERROR" or log.level == "FATAL" |
| Aritmético | \$1, -, \$1, / | response\$1time \$1 1000 > 5000 |
| Pertenencia a conjuntos | in, not in | environment in \$1"prod", "staging", "preprod"\$1 |
| Coincidencia de expresiones regulares | =\$1, \$1\$1 | message =\$1 "^ERROR.\$1timeout" |
## Funciones
`length(value)`
Devuelve la longitud de una cadena o matriz. Ejemplo:: `length(message) > 100`
`contains(value, search)`
Comprueba si una cadena contiene una subcadena o si una matriz contiene un elemento. Ejemplo:: `contains(message, "error")`
`startsWith(field, prefix)`
Comprueba si una cadena comienza con un prefijo especificado. Ejemplo:: `startsWith(message, "ERROR")`
## Expresiones de ejemplo
```
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"
```
## Limitaciones
+ La longitud máxima de una expresión es de 256 caracteres.
+ Los procesadores de análisis (excepto Grok) no admiten el procesamiento condicional. Esto incluye los analizadores JSON, CSV, KeyValue, WAF, Postgres, CloudFront, VPC, Route53 y OCSF.
+ Si el procesador Grok se utiliza como analizador (primer procesador) en una canalización y su condición `when` se evalúa como falsa, la canalización completa no se pone en marcha para ese evento de registro.