Pular para o conteúdo

AlertLint · Observabilidade

Teste as suas regras de alerta do Loki antes que disparem em produção.

O AlertLint permite testar as regras de alerta do Loki antes da produção: cole as suas regras e logs sintéticos, afirme quais alertas devem disparar e obtenha um sucesso ou uma falha, tudo on-line, sem instalar nada nem se cadastrar.

Roda no seu navegador Sem cadastro Gratuito e aberto Atualizado em 29 de jul. de 2026

Ambiente de testes do 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.

A lacuna

O Loki não tem promtool.

Os engenheiros do Prometheus vêm entregando regras de alerta testadas há anos com o promtool test rules: entram amostras sintéticas, sai um sucesso ou uma falha. O Loki adotou o mesmo formato de regras, mas nunca lançou o executor de testes, então os alertas de LogQL têm sido entregues sem testes: a única forma de saber se uma regra disparava era esperar pelo tráfego de produção.

A comunidade pede isso há anos — veja no Loki a issue nº 7655 e a issue nº 16659. O AlertLint preenche essa lacuna hoje: um testador unitário gratuito e executado no navegador para regras de alerta do Loki que usa o conhecido arquivo de testes no estilo do promtool e roda totalmente no lado do cliente.

Não conhece o formato? Vá direto para os dois arquivos ou experimente o ambiente de testes ao vivo acima.

O processo

Como funciona.

Cinco passos determinísticos rodam de ponta a ponta a cada toque em Executar — tudo dentro da aba do seu navegador, todas as vezes.

  1. Analisa as regras.

    O seu YAML do ruler do Loki é analisado em grupos de regras de alerta e de gravação — o mesmo formato que o ruler do Loki carrega.

  2. Analisa o arquivo de testes.

    O arquivo de testes modelado segundo o promtool é lido para obter as suas séries de logs de entrada, o intervalo de avaliação e os alertas que você espera.

  3. Monta um armazenamento em memória.

    As linhas de logs sintéticos são carregadas em um armazenamento de logs efêmero e no navegador para que as consultas tenham algo para ler.

  4. Avalia o LogQL.

    A expressão de cada regra é executada contra o armazenamento no momento de avaliação do teste, produzindo os alertas que disparariam.

  5. Compara com o esperado.

    Os alertas reais são comparados com os seus exp_alerts. Qualquer divergência é um caso com falha, informado inline.

Formatos de arquivo

Dois arquivos, ambos familiares.

O AlertLint lê exatamente duas entradas: o seu YAML do ruler do Loki e um arquivo de testes modelado segundo o promtool. Se você já escreveu algum deles para o Prometheus ou o Loki, vão parecer familiares.

O arquivo de regras

YAML padrão do ruler do Loki: groups de regras de alerta e de gravação, cada uma com uma expr de LogQL, uma duração for opcional e labels / annotations. É o mesmo arquivo que o seu ruler já carrega.

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

O arquivo de testes

Modelado segundo o promtool: input_streams de fluxos de logs sintéticos, um interval de avaliação e um alert_rule_test que enumera os alertas que você espera. Um exp_alerts: [] vazio afirma que nenhum alerta dispara.

tests.yaml
tests:
  - interval: 1m
    input_streams:
      - stream:
          app: checkout
        logs:
          - "1m  level=error checkout upstream timeout"
          - "2m  level=error checkout upstream timeout"
          - "3m  level=error checkout upstream timeout"
          - "4m  level=error checkout upstream timeout"
          - "5m  level=error checkout upstream timeout"
          - "6m  level=error checkout upstream timeout"
    alert_rule_test:
      - eval_time: 6m
        alertname: HighErrorRate
        exp_alerts:
          - exp_labels:
              severity: page
            exp_annotations:
              summary: "Checkout error rate is high"

  # Negative case — empty exp_alerts asserts NO alert fires.
  - interval: 1m
    input_streams:
      - stream:
          app: checkout
        logs:
          - "1m  level=info checkout ok"
          - "2m  level=info checkout ok"
    alert_rule_test:
      - eval_time: 6m
        alertname: HighErrorRate
        exp_alerts: []

Em breve

Rode as mesmas verificações na CI.

O motor do navegador é o primeiro passo. Uma CLI pronta para uso vai rodar as mesmas asserções sobre um glob de arquivos de testes no seu pipeline, de modo que um alerta quebrado faça a build falhar em vez de te acordar às 3 da manhã.

Uma Action própria do GitHub que encapsula a CLI também está planejada junto dela. Ambas chegam em breve — o testador no navegador acima já funciona hoje.

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 em versão preliminar

Uma observação sobre a precisão: o avaliador no navegador é um motor em versão preliminar que cobre os padrões comuns de alerta do LogQL — comparadores de rótulos, filtros de linha e de rótulo, agregações rate / count_over_time e comparações de limite. Em breve chegará uma build de paridade total que compila o motor de consultas oficial do Loki para WebAssembly. Até lá, considere uma execução em verde como uma forte confiança prévia à implantação, e não como uma reprodução de produção byte a byte.

FAQ

Suas perguntas, respondidas.

Toque em uma pergunta para expandir a resposta.

O AlertLint é um testador unitário gratuito e executado no navegador para regras de alerta e de gravação do Grafana Loki. Você cola o seu YAML do ruler do Loki mais um arquivo de testes modelado segundo o promtool com fluxos de logs sintéticos, aperta Executar, e o AlertLint avalia o LogQL e informa se os alertas que você esperava realmente dispararam. É o equivalente ao “test rules” do promtool que o Loki nunca lançou.

Não. O AlertLint roda 100% no lado do cliente. As suas regras e logs sintéticos são avaliados na aba do seu navegador — nada é enviado para um servidor, e não há conta nem cadastro. Você pode usá-lo com segurança em definições de regras internas ou sensíveis.

O Prometheus inclui o promtool test rules para fazer testes unitários de regras de alerta contra amostras sintéticas. O Loki não tem um equivalente integrado — não existe o comando loki test. O AlertLint preenche essa lacuna para o LogQL: você declara quais alertas devem disparar a partir de um determinado conjunto de linhas de log, antes que as regras cheguem à produção.

O avaliador em versão preliminar cobre os padrões comuns de alerta e de gravação — consultas de log e de métricas, seletores de fluxo, comparadores de rótulos, filtros de linha, agregações rate e count_over_time, agregações sum e comparações de limite frente aos alertas esperados. A paridade total com o motor de consultas oficial do Loki (Go compilado para WebAssembly) está prevista para uma versão futura.

Sim. Uma lista exp_alerts vazia em um caso de teste afirma que a regra não produz alertas no momento da avaliação — a mesma semântica de caso negativo que o promtool usa. É a forma canônica de provar que uma regra não vai disparar diante de um volume de logs benigno.

Não. O AlertLint é uma ferramenta comunitária e independente, e não é afiliado nem endossado pela Grafana Labs. Loki e Grafana são marcas registradas da Raintank, Inc. O AlertLint modela o formato de arquivo de testes do promtool por familiaridade e usa os nomes dos fornecedores apenas para descrever o que ele testa.

Antes de implantar, valide o YAML das suas regras com lokitool rules lint ou cortextool rules lint --backend=loki e faça uma execução de teste das suas consultas no Grafana Explore ou no logcli. Para testes prévios à implantação baseados em asserções — o passo que essas ferramentas não cobrem — cole as suas regras mais fluxos de logs sintéticos no AlertLint e afirme quais alertas devem disparar, incluindo os casos negativos. Uma execução em verde dá uma forte confiança prévia à implantação, embora o avaliador no navegador seja um motor em versão preliminar, e não uma reprodução completa de produção.

O lokitool e o cortextool oferecem os comandos rules lint e sync que validam a estrutura das regras e as enviam a um ruler do Loki — mas nenhum executa asserções de alerta com logs sintéticos nem diz se uma regra dispara. O AlertLint traz o fluxo de trabalho baseado em asserções, no estilo do promtool, para o LogQL: você fornece fluxos de logs sintéticos, declara quais alertas espera e recebe um veredito de sucesso ou falha, totalmente no navegador e sem instalar nada.

O AlertLint analisa o YAML padrão do ruler do Loki — grupos de regras de alerta e de gravação, cada uma com uma expr de LogQL, uma duração for opcional e labels/annotations — e informa os problemas estruturais inline. Para verificações mais profundas da política de expressões frente aos metadados das regras, o promruval com --support-loki é uma opção de CLI. O AlertLint roda totalmente no navegador e sem necessidade de cadastro.

More free, private DevOps tools.

O AlertLint é mais uma ferramenta do OpsCanopy: uma cobertura crescente de validadores, conversores e testadores baseados no navegador que nunca tocam um servidor.

29 ferramentas gratuitas, todas capazes de funcionar offline — o opscanopy.com não exige cadastro e não envia nada.

Combine-o com o já disponível conversor de ignorados de CVE e o validador do GitHub Actions, ou explore o diretório completo de ferramentas.

Não é afiliado nem endossado pela Grafana Labs. Loki e Grafana são marcas registradas da Raintank, Inc.