A última coisa que eu medi no Cardinality Guardian foi histograma, e ele não mexe nisso. Duzentas identidades de histograma entraram e duzentas saíram, em todos os modos. Neste laboratório isso dá 2.200 séries no Prometheus, porque cada identidade traz nove buckets, um sum e um count.
Uma identidade de counter é uma série. Uma identidade de histograma aqui são onze, então a mesma explosão de label custa onze vezes mais. O Prometheus guarda cada série ativa na memória, e a maioria dos vendors cobra por série ativa ou por métrica customizada.
Então adicionei uma suíte ao mesmo laboratório. Ela manda um histograma delta, em que cada exportação carrega só o que aconteceu desde a anterior. São 200 identidades (cada combinação única de labels), com um user.id ilimitado ao lado de um método e um status code limitados. Depois a suíte corta isso de sete jeitos, conta as séries e roda quatro queries PromQL fixas. Quantas observações a métrica carrega, o p95 mais alto entre os métodos HTTP, as observações com status 500, e o p95 de um usuário específico. O workload sempre registra 600 observações, então qualquer outro total quer dizer que a estratégia mudou a resposta. O p95 por usuário é a query que alguém roda quando um cliente reclama que está lento, e é por causa dela que o user.id foi parar num histograma.
Nenhuma dessas formas reduz identidade sem perder essa pergunta por usuário, porque é a identidade que distingue um usuário do outro. Uma opção deixa todas as identidades no lugar e deixa cada uma mais barata.
O que eu medi #
Docker local. Collector 0.162.0 verificado contra o checksum do release, Prometheus 3.15.0 por digest de imagem, SDK Python 1.45.0. Três repetições por estratégia, e todas concordaram.
| Estratégia | Séries | Contagem total | Status 500 | p95 por método | p95 de um usuário |
|---|---|---|---|---|---|
| Baseline, sem processor | 2.200 | 600 | 120 | responde | responde |
| Cardinality Guardian | 2.200 | 600 | 120 | responde | responde |
transform, delete_key | 220 | 60 | 12 | responde | nenhuma |
transform, aggregate_on_attributes | 220 | 600 | 120 | responde | nenhuma |
filter no atributo | 0 | nenhuma | nenhuma | nenhuma | nenhuma |
| View do SDK limitando atributos | 220 | 600 | 120 | responde | nenhuma |
tag_only com routing connector | 2.200 | 600 | 120 | responde | responde |
| Exponencial, lido como texto | 600 | 600 | 120 | nenhuma | nenhuma |
| Exponencial, lido como nativo | 200 | 600 | 120 | responde | responde |
As colunas de percentil dizem se a query devolve um número, não qual. Os valores são sintéticos e os números exatos estão no REPORT.md. A linha do Cardinality Guardian é a referência do post anterior, em strip_and_reaggregate.
O delete_key mudou meus números #
Apagar a chave problemática é a primeira coisa que eu tentaria.
transform:
metric_statements:
- delete_key(datapoint.attributes, "user.id")
Corta as séries, de 2.200 para 220. Também transformou 600 observações em 60, e as 120 requisições com status 500 em 12.
O statement roda uma vez por data point e não junta nada, então duzentos data points chegam no exporter do Prometheus carregando vinte identidades distintas. O accumulator.go do exporter na v0.162.0 trata histograma delta comparando o início do ponto que chega com o fim do ponto anterior da mesma identidade. Se batem, ele soma. Se não batem e o ponto novo não é posterior, ele descarta o ponto e loga um aviso. Depois do delete_key, dez pontos do mesmo burst caem na mesma identidade com o mesmo início e o mesmo fim, e nove são descartados. Sessenta é vinte identidades vezes três observações.
O log do Collector de cada rodada do delete_key tem Dropped misaligned histogram datapoint em nível warn, onze linhas por rodada porque o Collector amostra linhas repetidas. Nenhuma das outras dez estratégias loga aviso, e a suíte conta essas linhas no REPORT.md. A métrica em si parece normal. O dashboard renderiza e o p95 mexe um pouco, 9,375 contra 9,107 do baseline. Doze em 60 é 20%, e 120 em 600 é 20%, então um SLO em proporção não acusaria nada. O que fica errado por um fator de dez é o volume absoluto, o alerta de queda de tráfego, o planejamento de capacidade, qualquer painel de requisições por minuto. A proporção se manteve porque o descarte foi uniforme neste workload. Em produção depende de quais pontos colidem.
A versão que funciona roda no contexto de métrica e agrega.
transform:
metric_statements:
- context: metric
statements:
- aggregate_on_attributes("sum", ["environment", "region", "http.method", "http.status_code"])
As mesmas 220 séries, e a contagem volta para 600. O upstream documenta que só sum vale para histograma, o que faz sentido, já que bucket é contagem.
O filter faz uma terceira coisa. Uma condição sobre um atributo descarta os data points que carregam aquele atributo, e uma métrica sem data points vai junto. Todo data point aqui carrega user.id, então a métrica inteira saiu do pipeline. Zero séries, quatro queries vazias. O componente está fazendo o trabalho dele. Ele filtra pelo atributo, e eu tinha lido como se tirasse o atributo.
A view #
Uma view é uma regra na config do SDK do serviço que diz quais atributos um instrumento mantém antes de exportar.
View(
instrument_name="lab.bench.delta_histogram",
attribute_keys={"environment", "region", "http.method", "http.status_code"},
)
Vinte identidades, 220 séries, 600 observações, e o Collector nunca recebe as outras 180 identidades. Eu gosto que ela mora no código do time que colocou o user.id e sabe por quê. Ela também precisa de um deploy de cada serviço, e um time de plataforma não consegue aplicar isso de forma central com a explosão em curso.
Routing #
O README do upstream sugere juntar o tag_only com um routing connector para mandar as métricas marcadas para algum lugar barato, e eu repeti isso no post anterior sem rodar. Funciona e não reduz nada. Entram 2.200 séries, 220 vão para o exporter principal e 1.980 para o segundo. O backend caro para de ver a explosão, e a explosão continua lá.
Minha primeira condição não roteou nada.
routing:
table:
- condition: datapoint.attributes["otel.metric.overflow"] == "true"
Nenhum erro, config válida. O processor escreve o marcador com PutBool, e o Prometheus renderiza booleano como o valor de label true, então eu tinha escrito a condição contra o que parecia uma string. Booleano comparado com string dá sempre falso. Tirar as aspas resolve. O laboratório guarda as duas versões, porque a quebrada é a que eu teria colocado em produção.
O histograma exponencial #
Um histograma exponencial troca as fronteiras explícitas de bucket por uma escala. Aqui ele vem do SDK Python, com a ExponentialBucketHistogramAggregation e o Collector sem processor nenhum.
Lido como texto, que é como esse laboratório lê por padrão, as 200 identidades produzem 600 séries e as queries de p95 não retornam nada. O exporter Prometheus do Collector converte histograma exponencial para o formato nativo, um scrape em texto não carrega isso, e o que chega é um histograma só com o bucket +Inf. Eu teria publicado essa linha como “histograma exponencial não ajuda” se tivesse parado ali.
Com scrape_native_histograms: true no job de scrape, os mesmos dados chegam como 200 histogramas nativos, em que uma série só carrega todos os buckets dentro de cada amostra. Uma série por identidade em vez de onze, e as quatro queries respondem, incluindo o percentil por usuário. Nenhuma identidade saiu. Se isso vira economia depende da conta. Um backend que conta combinação de label não vê diferença, e um que conta série vê onze virar uma.
Os valores de percentil também dizem algo sobre a coluna que as outras estratégias perdem. No clássico, o p95 de um usuário saiu 4,750 para três observações que valem exatamente 1,0. O histogram_quantile assume que as observações se espalham por igual dentro do bucket em que o quantil cai, o meu bucket mais baixo vai de 0 a 5, e 95% de 5 é 4,75. O histograma nativo devolve 1,000. Por método dá 9,107 no clássico contra 6,999 no nativo, para observações que valem 6 e 7. Com buckets grossos assim, o p95 por usuário que a view e o aggregate_on_attributes perdem já era quase cinco vezes o valor real.
O que eu faria com isso #
A view evita a série, e o transform contém uma que já existe, que é do que eu preciso às 3h quando o serviço não é meu. Eu colocaria o aggregate_on_attributes no pipeline da plataforma e nunca o delete_key, que teria deixado minhas contagens de requisição erradas com só um aviso do exporter para contar. Eu moveria os histogramas caros para buckets exponenciais com scrape nativo, depois de checar o que o meu backend de verdade faz com histograma nativo, porque o meu é um Prometheus de laboratório.
A parte para a qual eu não tenho ferramenta é que a correção rápida na plataforma pode fazer o time dono do serviço nunca ficar sabendo que o histograma dele carregava um id de usuário.
O que este laboratório não diz #
Uma máquina, Docker Compose, 200 identidades. Não é modelo de capacidade, e as amostras de CPU são só contexto porque o gerador e o Collector dividem o mesmo host. Os valores do histograma são sintéticos e se repetem entre identidades.
Tudo é temporalidade delta. Um histograma cumulativo passa por outro ramo do mesmo exporter, que fica com o ponto de timestamp mais recente e descarta o resto sem log. Eu não medi o delete_key ali. O código sugere uma perda parecida, sem o aviso.
Histograma nativo aqui é o Prometheus 3.15.0 com scrape_native_histograms num job. Outros backends ingerem de outro jeito ou não ingerem, e eu não medi o caminho de remote write. As linhas de view e de exponencial são só o SDK Python. Não testei as estratégias combinadas.
Rode você mesmo #
git clone https://github.com/cauebraz/opentelemetry-cardinality-lab
cd opentelemetry-cardinality-lab
just setup
just check
just benchmark-histograms
A suíte leva uns nove minutos e escreve em results/histograms/ o relatório, o JSON cru por trás de cada célula acima e os logs do Collector de cada rodada. As estratégias são arquivos de config em config/.
Se o seu workload der números diferentes, abra uma issue no repositório do laboratório com a estratégia e o results.json. Eu quero saber quais dessas linhas só valem no meu laboratório.