Simple Log Service:Casos comuns de consulta ao Metricstore com PromQL e SQL

Consultar dados de uma única métrica

A métrica process_resident_memory_bytes reporta a memória residente de um processo. A consulta a seguir retorna todas as séries temporais dessa métrica no intervalo de tempo selecionado.

process_resident_memory_bytes

Filtrar dados de métricas por rótulo

Adicione seletores de rótulos dentro de {} para limitar os resultados a um valor específico de rótulo. A consulta abaixo retorna a memória residente apenas para o cluster sls-mall e converte bytes para MB.

process_resident_memory_bytes{cluster="sls-mall"}/1024/1024

Usar expressões regulares para filtragem de rótulos

Utilize =~ em vez de = para corresponder valores de rótulos a uma expressão regular. Esta consulta retorna dados em que o cluster é sls-mall ou sls-demo.

process_resident_memory_bytes{cluster=~"sls-mall|sls-demo"}

Calcular o valor máximo de uma métrica

A função max by (cluster) consolida todas as séries temporais de cada cluster em uma única série, mantendo apenas o maior valor em cada timestamp. A cláusula by (cluster) preserva o rótulo do cluster e remove todos os outros. O exemplo a seguir retorna o pico de memória heap por cluster em MB.

max by (cluster) (go_memstats_heap_inuse_bytes) / 1024 / 1024

Calcular o número de séries temporais de uma métrica

A função count() retorna a quantidade de séries temporais ativas correspondentes a um seletor. Use-a para verificar quantas instâncias reportam uma determinada métrica. A consulta seguinte conta todas as séries temporais de apiserver_request_total no cluster sls-mall.

count(apiserver_request_total{cluster="sls-mall"})

Calcular a taxa de variação de uma métrica ao longo do tempo

A função rate() calcula a taxa média de variação por segundo em uma janela de tempo. Ela foi projetada para métricas de contador que só aumentam — use-a para calcular utilização de cpu, throughput de requisições e taxas semelhantes. A consulta abaixo retorna a taxa de uso de cpu por segundo no último minuto.

rate(process_cpu_seconds_total[1m])

Calcular a diferença de uma métrica em relação a n minutos atrás

A função delta() calcula a diferença entre o primeiro e o último valor de uma métrica dentro de uma janela de tempo. Diferentemente de rate(), a função delta() funciona com medidores (gauges) — métricas que podem aumentar ou diminuir. Este exemplo retorna a variação na contagem de goroutines no último minuto.

delta(go_goroutines[1m])

Uso aninhado de múltiplos operadores e funções

Operadores e funções do PromQL podem ser aninhados. As expressões internas são avaliadas primeiro e passadas como entrada para a função externa. A consulta a seguir calcula primeiro a contagem máxima de requisições por cluster e recurso, e depois selecione as 3 principais combinações.

topk(3, max by (cluster, resource)(apiserver_request_total))

Cálculos entre múltiplos valores

O PromQL suporta operadores aritméticos padrão (+, -, *, /, %) em números simples. O exemplo abaixo resulta em 3.

1 + 2

Cálculos entre métricas e valores

Operadores aritméticos também se aplicam entre uma métrica e um escalar. Esta consulta converte a métrica process_resident_memory_bytes de bytes para MB.

process_resident_memory_bytes / 1024 / 1024

Operações binárias entre múltiplas métricas

O PromQL permite operações binárias entre duas métricas. A correspondência ocorre com base nos conjuntos de rótulos — apenas séries temporais com rótulos idênticos em ambas as métricas são pareadas. A consulta seguinte calcula a proporção de pods DaemonSet prontos em relação aos pods agendados.

kube_daemonset_status_number_ready{job="kube-state-metrics"} 
/ 
kube_daemonset_status_desired_number_scheduled{job="kube-state-metrics"}

Como usar subconsultas corretamente

Funções como rate(), delta(), increase() e {agg}_over_time() operam apenas em dados brutos de métricas — elas não aceitam a saída de um operador de agregação como entrada. Use uma subconsulta para contornar essa restrição.

A sintaxe [a:b] em uma subconsulta especifica o intervalo (a) e o passo (b).

• Suportado — max_over_time aplicado a uma métrica bruta:

  max_over_time(go_goroutines[1m]) # Returns the maximum goroutine count in the previous minute, per time series.

• Não suportado — max_over_time aplicado a um resultado agregado:

  max_over_time(max(go_goroutines)[1m]) # Invalid: max(go_goroutines) produces a scalar, not a raw metric.

• Uso correto — utilize uma subconsulta para aplicar a função de intervalo após a agregação:

  # First aggregate across time series, then apply the range function via subquery.
  max_over_time(max(go_goroutines)[1m:10s])
  # [1m:10s] — evaluate max(go_goroutines) at 10-second steps over the past 1 minute, then take the max of those values.

Consultar todos os dados brutos de uma métrica

Retorne todas as séries temporais e amostras de process_resident_memory_bytes dentro do intervalo de tempo selecionado. (Demo )

 *| SELECT * FROM "metrics_store_name.prom" WHERE __name__ = 'process_resident_memory_bytes'

Consultar dados brutos com um valor de instância específico para uma métrica

Estenda a consulta anterior com element_at() para filtrar por um valor de rótulo específico. A consulta a seguir retorna todas as amostras em que a métrica é process_resident_memory_bytes e a instância é 172.20.0.143:8084. (Demo)

*| SELECT * FROM "metrics_store_name.prom" WHERE __name__ = 'process_resident_memory_bytes' and element_at(__labels__, 'instance')='172.20.0.143:8084' limit all

Agregar dados de séries temporais por minuto

Alinhe os timestamps aos limites de minuto e calcule o valor máximo da métrica por instância. (Demo)

*| SELECT (__time_nano__ - __time_nano__ % 60000000)/1000000.0 as t, element_at(__labels__, 'instance') as instance, max(__value__) as val FROM "metrics_store_name.prom" WHERE __name__ = 'process_resident_memory_bytes' group by t, instance limit all