Pular para o conteúdo

LogQL ↔ PromQL · Observabilidade

Traduza entre LogQL e PromQL.

Um conversor gratuito de LogQL para PromQL que funciona online, inteiramente no seu navegador. Cole uma consulta, escolha uma direção e receba uma reescrita limpa das partes que se convertem, mais notas honestas sobre as partes que não.

Funciona no seu navegador Sem cadastro Grátis e aberto Atualizado em 28 de jul. de 2026

Ambiente de testes do LogQL ↔ PromQL Helper

Direction
Loading…
query.logql

Tip: press Esc to release focus.

query.promql
read-only
Notes

Pick a direction, paste or load a query, then convert to see the translated query and notes on what does and does not map here.

A lacuna

Mesma gramática, mundos diferentes.

LogQL foi modelado deliberadamente com base no PromQL: a sintaxe dos seletores, as funções de vetor de intervalo e os operadores de agregação parecem quase idênticos. Por isso, os engenheiros que usam ao mesmo tempo Loki e Prometheus querem o tempo todo levar uma consulta de um para o outro — e recorrem ao buscar e substituir, que quebra silenciosamente nas partes que não se encaixam.

O detalhe é que o PromQL só chega a enxergar amostras já agregadas, enquanto o LogQL também pode filtrar e reestruturar linhas de log em estado bruto. Os filtros de linha, os analisadores e line_format não têm nenhum equivalente em PromQL. Este conversor de consultas do Loki faz por você o tedioso mapeamento de métricas e, o que é igualmente importante, te diz exatamente quais peças ele não conseguiu traduzir — para que você as corrija de propósito, em vez de por surpresa.

Novo nessas diferenças? Pule para o que se converte e o que não ou experimente o ambiente de testes ao vivo acima.

A pipeline

Como funciona.

Cinco passos determinísticos rodam de ponta a ponta a cada vez que você aperta Converter — todos dentro da aba do seu navegador, sempre.

  1. Analisa a consulta.

    Sua consulta de origem é decomposta em suas partes estruturais — seletores, funções de intervalo, agregações e comparações — na linguagem que você escolheu.

  2. Mapeia o formato da métrica.

    As construções que compartilham gramática — seletores, rate/over_time, sum by (…), limites — são mapeadas uma a uma para a linguagem de destino.

  3. Isola o que não pode ser convertido.

    As peças do LogQL exclusivas de logs — filtros de linha, analisadores, line_format — são separadas, já que o PromQL não tem equivalente para elas.

  4. Gera a tradução.

    A consulta reescrita é exibida na linguagem de destino, pronta para copiar no Grafana, em um arquivo de regras ou em um alerta.

  5. Informa as notas.

    Tudo o que envolve perda ou não pode ser convertido aparece como uma nota em linguagem clara, para que você saiba exatamente o que verificar à mão.

O que se converte

O que se traduz e o que não.

As consultas de métricas compartilham gramática e se convertem de forma limpa. As consultas de logs — a parte que lê linhas em estado bruto — são onde as duas linguagens se separam. Aqui está a distinção honesta.

Converte de forma limpa

Os seletores de labels, as funções de vetor de intervalo (rate, increase, count_over_time), os operadores de agregação com agrupamento by / without e as comparações de limite compartilham uma sintaxe quase idêntica. O mesmo formato em LogQL vira o mesmo formato em PromQL.

source.logql
# LogQL metric query — error rate from a log stream
sum by (app) (
  rate({app="checkout", env="prod"} |= "error" [5m])
) > 0.2
result.promql
# PromQL — the same aggregation shape over a counter metric
sum by (app) (
  rate(app_request_errors_total{app="checkout", env="prod"}[5m])
) > 0.2

Não tem equivalente

O PromQL só enxerga amostras numéricas, então as partes do LogQL que operam sobre o texto de log em estado bruto simplesmente não existem do outro lado. Os filtros de linha (|= "error"), os analisadores (| json, | logfmt), line_format e label_format são informados como notas, nunca descartados silenciosamente.

log-only.logql
# These LogQL pieces have NO PromQL equivalent:
{app="checkout"} |= "error"            # line filter — PromQL sees samples, not lines
| json | line_format "{{.msg}}"        # parsers + line_format reshape log text
| label_format level=`{{.severity}}`   # label_format rewrites labels at query time

Motor de pré-visualização

Uma nota sobre a precisão: o tradutor no navegador é um motor de pré-visualização que mapeia os formatos comuns de consultas de métricas — seletores de labels, funções de vetor de intervalo como rate / count_over_time, agregações com by / without e comparações de limite. Ele não executa um analisador completo de LogQL nem de PromQL, e não pode inventar um nome de métrica para uma série derivada de logs. Trate o resultado dele como um ótimo primeiro rascunho para revisar — não como um substituto garantido para regras de produção.

FAQ

Suas perguntas, respondidas.

Toque em uma pergunta para expandir a resposta.

Ele traduz os formatos comuns de consultas de métricas entre o LogQL do Grafana Loki e o PromQL do Prometheus, nos dois sentidos. Cole uma consulta, escolha uma direção e o ajudante reescreve os seletores, as funções de intervalo e as agregações para a outra linguagem — e então sinaliza tudo o que não pode ser convertido de forma limpa. Ele funciona inteiramente no seu navegador, sem conta e sem upload.

Não. O ajudante é 100% no lado do cliente. Suas consultas são analisadas e reescritas dentro da aba do seu navegador — nada é enviado para um servidor e não há cadastro. Você pode colar com total segurança nomes de labels internos, namespaces e identificadores de serviços.

Não, e o ajudante deixa isso claro. LogQL e PromQL compartilham a mesma gramática de seletores e agregações para consultas de métricas, então formatos como rate(), count_over_time(), sum by (…) e comparações de limite são traduzidos bem. Mas as consultas de logs do LogQL — filtros de linha como |= "error", label_format, line_format e os analisadores de padrão ou expressão regular — não têm equivalente em PromQL, porque o PromQL só enxerga amostras já agregadas. Essas partes são informadas como notas em vez de descartadas silenciosamente.

Os seletores de labels ({app="checkout", env=~"prod|stage"}), as funções de vetor de intervalo (rate, irate, increase, *_over_time), os operadores de agregação (sum, avg, max, min, count, topk) com agrupamento by/without e as comparações binárias ou de limite compartilham uma sintaxe quase idêntica. O ajudante converte tudo isso diretamente e mantém intactos os nomes dos seus labels e suas durações.

As equipes costumam usar Loki e Prometheus ao mesmo tempo e querem que uma métrica já validada em um exista também no outro — por exemplo, transformar uma taxa de erros derivada de logs no Loki em um formato de recording rule sobre o qual possam raciocinar comparando com as métricas do Prometheus, ou portar um limite de alerta do PromQL para um equivalente em LogQL sobre um fluxo de logs. O ajudante te dá um primeiro rascunho rápido mais uma lista clara do que vale conferir com atenção.

O PromQL consulta métricas numéricas já agregadas armazenadas no Prometheus; o LogQL consulta fluxos de logs no Grafana Loki e pode derivar métricas deles em tempo de consulta. Ambos compartilham uma sintaxe de seletores de labels idêntica e os mesmos operadores de agregação (sum, avg, max), mas o LogQL adiciona uma pipeline final de filtros e analisadores — separados por | — que não tem contrapartida em PromQL. A diferença está no modelo de dados: amostras numéricas versus linhas de log em estado bruto.

Mantenha os seletores de labels como estão — os seletores de fluxo do LogQL usam a mesma sintaxe {label="value"}. Depois, envolva o seletor em uma agregação de intervalo como rate(), count_over_time() ou sum_over_time() e adicione um intervalo como [5m]. Como o Loki não tem séries de métricas preexistentes, você também precisará apontar o seletor para um fluxo de logs real e, com frequência, adicionar uma etapa de análise (| json ou | logfmt) para extrair os labels pelos quais você quer agrupar.

As funções que pressupõem séries instrumentadas preexistentes não se traduzem diretamente. histogram_quantile não tem contrapartida direta em LogQL (em vez dela, você precisaria de quantile_over_time com um label desempacotado). irate() é aproximado por rate() em LogQL, já que o Loki não tem uma função equivalente de taxa instantânea. A correspondência binária de vetores do PromQL sobre pares de métricas também é mais limitada em LogQL, que opera sobre fluxos de logs em vez de séries numéricas.

Sim. O LogQL foi modelado deliberadamente com base no PromQL: os seletores de fluxo usam a sintaxe {label="value"} idêntica e as consultas de métricas do LogQL reutilizam os mesmos operadores de agregação — sum, avg, max, topk, by/without. A adição principal é a pipeline de logs para filtrar e analisar linhas de log em estado bruto, de modo que engenheiros já familiarizados com PromQL conseguem ler as consultas de métricas do LogQL com um ajuste mínimo.

Não. Esta é uma ferramenta independente e comunitária, e não é afiliada nem endossada pelo Grafana Labs nem pelo projeto Prometheus. Loki e Grafana são marcas registradas da Raintank, Inc.; Prometheus é marca registrada da The Linux Foundation. Os nomes dos fornecedores são usados apenas para descrever as linguagens de consulta que o ajudante traduz.

More free, private DevOps tools.

O LogQLPromQL Helper fica ao lado do resto do cluster de observabilidade do OpsCanopyexplique uma consulta PromQL ou teste suas regras de alerta do Loki com AlertLint, tudo baseado no navegador e privado por padrão.

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

Quer o conjunto completo? Explore o diretório de ferramentas completo, ou leia por que tudo aqui funciona inteiramente no lado do cliente.

Não é afiliado nem endossado pelo Grafana Labs nem pelo projeto Prometheus. Loki e Grafana são marcas registradas da Raintank, Inc.; Prometheus é marca registrada da The Linux Foundation.