Saltar al contenido

AlertLint · Observabilidad

Prueba tus reglas de alertas de Loki antes de que se disparen en producción.

AlertLint te permite probar las reglas de alertas de Loki antes de producción: pega tus reglas y logs sintéticos, afirma qué alertas deberían dispararse y obtén un éxito o un fallo, todo en línea sin instalar nada ni registrarte.

Se ejecuta en tu navegador Sin registro Gratuito y abierto Actualizado el 19 jul 2026

Entorno de pruebas de AlertLint

rules.yaml

Runs in your browser — nothing is uploaded.

Tip: press Esc to release focus.

test.yaml
Results

Load an example or paste your own rules, then run to see pass/fail results here.

La carencia

Loki no tiene promtool.

Los ingenieros de Prometheus llevan años desplegando reglas de alertas probadas con promtool test rules: entran muestras sintéticas, sale un éxito o un fallo. Loki adoptó el mismo formato de reglas pero nunca incluyó el ejecutor de pruebas, así que las alertas de LogQL se han desplegado sin probar: la única forma de saber si una regla se disparaba era esperar al tráfico de producción.

La comunidad lo ha pedido durante años: consulta en Loki la incidencia n.º 7655 y la incidencia n.º 16659. AlertLint cubre esa carencia hoy: un tester unitario gratuito y basado en el navegador para reglas de alertas de Loki que usa el conocido archivo de pruebas al estilo de promtool y se ejecuta por completo del lado del cliente.

¿No conoces el formato? Salta a los dos archivos o prueba el entorno de pruebas en vivo de arriba.

El proceso

Cómo funciona.

Cinco pasos deterministas se ejecutan de principio a fin con cada pulsación de Ejecutar, todo dentro de la pestaña de tu navegador, siempre.

  1. Analiza las reglas.

    Tu YAML del ruler de Loki se analiza en grupos de reglas de alertas y de registro: la misma forma que carga el ruler de Loki.

  2. Analiza el archivo de pruebas.

    El archivo de pruebas modelado según promtool se lee para obtener sus series de logs de entrada, el intervalo de evaluación y las alertas que esperas.

  3. Construye un almacén en memoria.

    Las líneas de logs sintéticos se cargan en un almacén de logs efímero y en el navegador para que las consultas tengan algo que leer.

  4. Evalúa el LogQL.

    La expresión de cada regla se ejecuta contra el almacén en el momento de evaluación de la prueba, produciendo las alertas que se dispararían.

  5. Compara con lo esperado.

    Las alertas reales se comparan con tus exp_alerts. Cualquier discrepancia es un caso fallido, informado en línea.

Formatos de archivo

Dos archivos, ambos familiares.

AlertLint lee exactamente dos entradas: tu YAML del ruler de Loki y un archivo de pruebas modelado según promtool. Si ya has escrito alguno de ellos para Prometheus o Loki, te resultarán muy familiares.

El archivo de reglas

YAML estándar del ruler de Loki: groups de reglas de alertas y de registro, cada una con una expr de LogQL, una duración for opcional y labels / annotations. Es el mismo archivo que tu ruler ya carga.

rules.yaml
groups:
  - name: app-errors
    rules:
      - alert: HighErrorRate
        expr: |
          sum(rate({app="checkout"} |= "error" [5m])) > 0.2
        for: 2m
        labels:
          severity: page
        annotations:
          summary: "Checkout error rate is high"

El archivo de pruebas

Modelado según promtool: input_series de flujos de logs sintéticos, un interval de evaluación y un alert_rule_test que enumera las alertas que esperas. Un exp_alerts: [] vacío afirma que no se dispara ninguna alerta.

tests.yaml
tests:
  - interval: 1m
    input_series:
      - stream: '{app="checkout"}'
        # 5 error lines/min for 6 minutes
        values: '{level="error"}x6'
    alert_rule_test:
      - eval_time: 6m
        alertname: HighErrorRate
        exp_alerts:
          - exp_labels:
              severity: page
              app: checkout
            exp_annotations:
              summary: "Checkout error rate is high"

  # Negative case — empty exp_alerts asserts NO alert fires.
  - interval: 1m
    input_series:
      - stream: '{app="checkout"}'
        values: '{level="info"}x6'
    alert_rule_test:
      - eval_time: 6m
        alertname: HighErrorRate
        exp_alerts: []

Próximamente

Ejecuta las mismas comprobaciones en CI.

El motor del navegador es el primer paso. Una CLI lista para usar ejecutará las mismas aserciones sobre un glob de archivos de pruebas en tu pipeline, de modo que una alerta rota rompa la compilación en lugar de avisarte a las 3 de la madrugada.

También se planea una Action propia de GitHub que envuelve la CLI junto a ella. Ambas llegan próximamente; el tester en el navegador de arriba ya funciona hoy.

ci.sh
# Coming soon — the same engine as a CLI
$ alertlint test ./tests/**.yaml

  ✓ app-errors › HighErrorRate (fires)
  ✓ app-errors › HighErrorRate (no-fire on info logs)

  2 passed, 0 failed

Motor en versión preliminar

Una nota sobre la precisión: el evaluador en el navegador es un motor en versión preliminar que cubre los patrones habituales de alertas de LogQL: comparadores de etiquetas, filtros de línea y de etiqueta, agregaciones rate / count_over_time y comparaciones de umbral. Próximamente llegará una versión de paridad total que compila el motor de consultas oficial de Loki a WebAssembly. Hasta entonces, considera una ejecución en verde como una sólida confianza previa al despliegue, no como una reproducción de producción byte a byte.

FAQ

Tus preguntas, respondidas.

Toca una pregunta para desplegar la respuesta.

AlertLint es un tester unitario gratuito y basado en el navegador para reglas de alertas y de registro de Grafana Loki. Pegas tu YAML del ruler de Loki más un archivo de pruebas modelado según promtool con flujos de logs sintéticos, pulsas Ejecutar y AlertLint evalúa el LogQL e informa si las alertas que esperabas realmente se dispararon. Es el equivalente al “test rules” de promtool que Loki nunca incluyó.

No. AlertLint se ejecuta 100% del lado del cliente. Tus reglas y logs sintéticos se evalúan en la pestaña de tu navegador: nada se sube a un servidor y no hay cuenta ni registro. Puedes usarlo con total seguridad sobre definiciones de reglas internas o sensibles.

Prometheus incluye promtool test rules para hacer pruebas unitarias de las reglas de alertas contra muestras sintéticas. Loki no tiene un equivalente integrado: no existe el comando loki test. AlertLint cubre esa carencia para LogQL: declaras qué alertas deberían dispararse a partir de un conjunto dado de líneas de log, antes de que las reglas lleguen a producción.

El evaluador en versión preliminar cubre los patrones habituales de alertas y de registro: consultas de logs y de métricas, selectores de flujos, comparadores de etiquetas, filtros de línea, agregaciones rate y count_over_time, agregaciones sum y comparaciones de umbral frente a las alertas esperadas. La paridad total con el motor de consultas oficial de Loki (Go compilado a WebAssembly) está prevista para una versión futura.

Sí. Una lista exp_alerts vacía en un caso de prueba afirma que la regla no produce alertas en el momento de la evaluación: la misma semántica de caso negativo que usa promtool. Es la forma canónica de demostrar que una regla no se disparará ante un volumen de logs benigno.

No. AlertLint es una herramienta comunitaria e independiente, y no está afiliada a Grafana Labs ni respaldada por esta. Loki y Grafana son marcas comerciales de Raintank, Inc. AlertLint modela el formato de archivo de pruebas de promtool por familiaridad y usa los nombres de los proveedores únicamente para describir lo que prueba.

Antes de desplegar, valida el YAML de tus reglas con lokitool rules lint o cortextool rules lint --backend=loki y haz una ejecución de prueba de tus consultas en Grafana Explore o logcli. Para pruebas previas al despliegue basadas en aserciones —el paso que esas herramientas no cubren— pega tus reglas más flujos de logs sintéticos en AlertLint y afirma qué alertas deberían dispararse, incluidos los casos negativos. Una ejecución en verde da una sólida confianza previa al despliegue, aunque el evaluador en el navegador es un motor en versión preliminar, no una reproducción de producción completa.

lokitool y cortextool ofrecen los comandos rules lint y sync que validan la estructura de las reglas y las envían a un ruler de Loki, pero ninguno ejecuta aserciones de alertas con logs sintéticos ni te dice si una regla se dispara. AlertLint lleva el flujo de trabajo basado en aserciones, al estilo de promtool, a LogQL: tú aportas flujos de logs sintéticos, declaras qué alertas esperas y obtienes un veredicto de éxito o fallo, todo en el navegador y sin instalar nada.

AlertLint analiza el YAML estándar del ruler de Loki —grupos de reglas de alertas y de registro, cada una con una expr de LogQL, una duración for opcional y labels/annotations— e informa de los problemas estructurales en línea. Para comprobaciones más profundas de la política de expresiones frente a los metadatos de las reglas, promruval con --support-loki es una opción de CLI. AlertLint se ejecuta por completo en el navegador y sin necesidad de registro.

More free, private DevOps tools.

AlertLint es una herramienta más de OpsCanopy: una creciente cubierta de validadores, conversores y testers basados en el navegador que nunca tocan un servidor.

29 herramientas gratuitas, todas pueden funcionar sin conexión — opscanopy.com funciona sin registro y sin subir nada.

Combínalo con el ya disponible conversor de ignorados de CVE y el validador de GitHub Actions, o explora el directorio completo de herramientas.

No está afiliado a Grafana Labs ni respaldado por esta. Loki y Grafana son marcas comerciales de Raintank, Inc.