16. Cadenas de preprocesamiento -orden de ejecución, fallos-

Comprender el impacto del orden y la validación de múltiples pasos de preprocesamiento

Introducción operativa

*Cada paso de preprocesamiento transforma el dato recibido.

Si un paso falla, la cadena se detiene, y el ítem se marca como “not supported”.*

Zabbix aplica los pasos de preprocesamiento en el orden exacto en que están definidos. Cada transformación recibe como entrada la salida del paso anterior.

Por eso, el orden es crítico, y un solo error invalida toda la cadena.

🧩 Ejecución secuencial

Ejemplo de cadena mal ordenada:


1. Trim right: " °C"

2. JSONPath: $.data.temp

3. Custom multiplier: 0.1

Si el JSON aún no tiene " °C", Trim right no hará nada. Si JSONPath falla, los demás pasos nunca se ejecutan.

✔️ Orden correcto:


1. JSONPath: $.data.temp

2. Trim right: " °C"

3. Custom multiplier: 0.1

Reglas clave del preprocesamiento

| Regla                | Descripción                                                               |

| -------------------- | ------------------------------------------------------------------------- |

| Orden secuencial     | Cada paso depende del anterior. No hay “paralelismo”.                     |

| Falla = abortar      | Si un paso devuelve error, Zabbix no ejecuta los siguientes.              |

| Sin rollback         | No hay forma de “recuperarse” de un error intermedio.                     |

| Validación inmediata | El ítem se vuelve “not supported” si falla un paso, incluso una sola vez. |

🧪 Diagnóstico de fallos en cadenas

GUI → Monitoring → Latest data

  • Ítem marcado como not supported

  • Tooltip o ícono rojo al pasar el mouse sobre el nombre

Log del Server o Proxy


tail -f /var/log/zabbix/zabbix_server.log

Ejemplo de mensaje:


item "server01:custom.temp.raw" became not supported: Preprocessing step #2 failed: cannot apply regular expression

Casos reales de errores comunes

| Error de cadena                                | Causa                                                     | Solución                                                 |

| ---------------------------------------------- | --------------------------------------------------------- | -------------------------------------------------------- |

| JSONPath antes de validar si el JSON es válido | El JSON está mal formado y se rompe la extracción         | Agregar paso previo: Check for not supported           |

| Custom multiplier sobre texto                  | El valor aún contiene letras o símbolos                   | Aplicar Trim o RegExp antes del multiplicador        |

| Reemplazo sobre string nulo (null)           | No se valida la existencia del valor antes de transformar | Paso previo: Check for not supported, o control con JS |

| RegExp sin coincidencias                       | Expresión no encuentra patrón y falla                     | Validar contra valores reales antes de activar           |

| JavaScript sin return                        | Resultado es undefined                                  | Asegurarse de finalizar con return <valor>             |

Recomendación de diseño

Validar siempre primero, transformar después.

Orden sugerido de pasos:

  1. Check for not supported

  2. JSONPath / XML / RegExp

  3. Trim / Replace / Normalización

  4. Custom multiplier / Round / Convert

  5. Descartar sin cambios (Discard unchanged)

  6. JavaScript (si aplica lógica compleja)

Ejemplo completo: sensor vía API que devuelve "Temp: 312"

Objetivo: obtener 31.2

Valor recibido:


"Temp: 312"

Cadena de preprocesamiento correcta:


1. RegExp: Temp:\s*(\d+) → \1

2. Custom multiplier: 0.1

✔️ Resultado: 31.2

🧪 Si se invierte el orden, el multiplicador se aplica a un string y falla.

Tips para el operador

  • Siempre probar los pasos uno por uno, no todos al mismo tiempo.

  • Usar ítems clonados para pruebas.

  • Documentar cada paso en las notas del ítem.

  • Validar el dato en bruto en “Latest data” antes de activar la cadena.

🧠 Reflexión operativa

*El preprocesamiento es una herramienta poderosa, pero sensible a errores lógicos.

Un paso mal ubicado convierte datos valiosos en fallos invisibles.*

Un operador entrenado diseña cadenas robustas, valida paso a paso, y sabe diagnosticar fallas por orden incorrecto.

✅ Resultado esperado

  • El operador entiende que los pasos de preprocesamiento se ejecutan secuencialmente

  • Reconoce que una falla en un paso detiene toda la cadena

  • Sabe diagnosticar errores comunes por orden incorrecto o datos mal formateados

  • Es capaz de diseñar cadenas robustas con validación previa y transformación ordenada

---****