Operação
Benchmark
Este benchmark foi executado. Em 2026-09-22, um script empurrou uma carga de
remote-write determinística para o Prometheus 3.1.0, para o VictoriaMetrics single-node
v1.152.0 e para o engine Orbit Stack na mesma máquina, sequencialmente, e mediu disco,
throughput de ingest, memória residente e latência de consulta nos três. Todo número de engine
em CLAIMS.md vem dessas execuções, os relatórios estão registrados em
services/rust/orbit-stack/bench/runs/ e o script que os produziu é
services/rust/orbit-stack/bench/run.sh. Em 2026-09-23 um segundo harness,
services/rust/orbit-stack/bench/soak.sh, rodou o engine contra o VictoriaMetrics do jeito que o
VictoriaMetrics/prometheus-benchmark roda um banco, com churn e uma suíte de regras de
alerta; a primeira execução dele está abaixo, sob um título próprio, com a derrota que ela
encontrou. Um terceiro, services/rust/orbit-stack/bench/traces.sh, compara os traces do engine
com os do Grafana Tempo; a segunda rodada dele, como um crítico independente a executou
de novo, está mais abaixo com as derrotas, e os números de trace anteriores foram retirados.
Esta página é o método como foi executado, os resultados, e o que eles dizem e não dizem.
Todos os números desta página fora da seção de 2026-10-03 foram medidos no engine em Go, que
agora vive na tag git go-oracle. O engine que é entregue é o em Rust, em services/rust/orbit-stack, e os scripts
o medem. Este repositório não compila mais Go, então os comandos abaixo rodam as mesmas cargas
no engine em Rust, e não no engine dos números. As execuções do próprio engine
em Rust também estão registradas em bench/runs/ (os nomes delas levam rust); esta página
imprime só as que a seção de 2026-10-03 nomeia.
2026-10-03: a stack em Rust, antes e depois de uma rodada de performance
Um builder por produto, cada um medido contra o concorrente direto e depois revisado: relatório
services/rust/orbit-stack/bench/runs/2026-10-03-perf-round.md. A máquina foi compartilhada
pelos seis ao mesmo tempo (load de 6 a 32), então as colunas de concorrentes medidas pelos
builders ficam só nesse relatório. Esta página imprime apenas as linhas que um revisor executou
de novo depois, lado a lado, com load de 4 a 7.
| Número, conferido de novo | Antes | Depois | Concorrente na mesma execução |
|---|---|---|---|
| Busca de trace por um atributo que um único trace tem, 1,13 M de spans, p50 | 447 ms | 8,0 ms | nenhum |
| Busca de trace por um atributo que nenhum trace tem, 1,13 M de spans, p50 | 427 ms | 6,1 ms | nenhum |
PromQL rate(...[5m]) com resposta de 3,5 MB, 20 mil séries, p50 | 19,1 ms | 11,2 ms | nenhum |
PromQL sum by (instance) (rate(...[5m])), 20 mil séries, p50 | 7,9 ms | 5,3 ms | nenhum |
| orbit-collector, traces por gRPC a ~44 mil spans/s, cores de CPU | 0,36 a 0,39 | 0,25 a 0,26 | otelcol-contrib 0.161.0: 0,49 a 0,59 |
| orbit-collector, traces por HTTP, cores de CPU | 0,33 a 0,35 | 0,23 | otelcol-contrib: 0,55 a 0,69 |
| orbit-collector, RSS | 9 MiB | 10 MiB | otelcol-contrib: 219 a 221 MiB |
| orbit-agent, 500 mil séries, RSS estável | 257 MB | 90 a 93 MB | nenhum |
Não confirmado na nova execução: a CPU por amostra do orbit-agent (vitória em uma rodada, empate na outra) e o WAL dele, que ainda grava 48,8 B por amostra, enquanto o modo agent do Prometheus e o Alloy gravam 5,3. As linhas de trace não foram executadas de novo com 3,4 M de spans, onde as derrotas de "Traces contra o Grafana Tempo" foram medidas, então essas linhas de derrota continuam valendo.
Resultados
Os defaults do próprio Prometheus: blocos de 2 h nos dois engines que têm blocos. 20.000 séries ativas, 4 h de tempo virtual a um scrape de 15 s, 19,2 M de amostras por engine, empurradas tão rápido quanto cada engine as aceitou.
| Medida | Prometheus 3.1.0 | VictoriaMetrics v1.152.0 | Orbit Stack | vs Prometheus | vs VictoriaMetrics |
|---|---|---|---|---|---|
| Disco por amostra, blocos selados | 5,38 B | 2,24 B | 1,87 B | 2,9x | 1,2x |
| Disco por amostra, diretório de dados inteiro | 11,45 B | 2,24 B | 1,87 B | 6,1x | 1,2x |
| Ingest aceito, amostras/s | 467k | 567k | 555k | 1,19x | 0,98x (paridade) |
| RSS com o head cheio (20k séries x 4 h) | 257 MiB | 263 MiB | 105 MiB | 2,4x menos | 2,5x menos |
| Heap Go vivo naquele instante | 165 MiB | 181 MiB | 46 MiB | 3,6x menos | 4,0x menos |
| RSS depois de o head ser selado em bloco | n/a | n/a | 29 MiB | n/a | n/a |
query_range p50 / p90 em 60 execuções, só respostas | 97 / 108 ms | 16 / 20 ms | 24 / 33 ms | 4,0x / 3,3x mais rápida | 1,5x / 1,7x mais lenta |
query_range máximo (a primeira consulta carrega os frames em que ela cai) | 152 ms | 33 ms | 102 ms | 1,5x mais rápida | mais lenta |
| Erros de escrita | 0 | 0 | 0 | n/a | n/a |
O VictoriaMetrics faz cache de resultados de rollup por padrão; a linha acima é o número com
cache, e a mesma consulta com nocache=1 responde em 16,1 / 19,9 ms, então não é o cache que a
faz vencer. Nem o Prometheus nem o Orbit Stack fazem cache de resposta de consulta. A linha de
query_range do engine foi corrigida em 2026-09-23: a execução cronometrou as recusas 429
do limitador de leituras junto com as respostas, e, medida só sobre as respostas, ela é os
24 / 33 ms acima (CLAIMS.md, a partir da nova checagem em
bench/runs/2026-09-23-continuity-critic/).
Com 200.000 séries (2 h de tempo virtual, 96 M de amostras por engine, blocos de 2 h, de
modo que o Prometheus ainda não havia cortado um bloco): ingest de 582k contra os 520k do
VictoriaMetrics e os 429k do Prometheus, 2,20 B por amostra contra 2,33 B e 13,54 B. O p50
de query_range é de 68 ms contra os 506 ms do Prometheus e os 54 ms do VictoriaMetrics:
1,3x atrás da resposta com cache dele e 1,4x à frente da sem cache (93 ms). A primeira
consulta depois do selamento é de 259 ms contra os 248 ms do VictoriaMetrics. O RSS é de 511 MiB contra os
856 MiB do Prometheus e os 312 MiB do VictoriaMetrics: o engine vence o Prometheus nesta
escala e fica 64% acima do VictoriaMetrics, que é a maior lacuna restante. O head cai para
77 MiB no instante em que é selado. Relatório:
bench/runs/2026-09-22-200k-2h-2hblocks-bursty.md.
As tabelas acima são a entropia padrão do script, ruído de counter de 0,3 (o perfil em rajadas,
veja Carga de trabalho). O perfil estável, ruído de 0,05, com 20.000 séries sobre 4 h
(bench/runs/2026-09-22-20k-4h-2hblocks-steady.md): 5,215 B contra os 1,983 B do
VictoriaMetrics e os 1,724 B do engine em blocos selados, ingest de 363.658 / 485.841 /
513.798 amostras/s, RSS de 214 / 235 / 141 MiB, p50 de consulta de 103,5 / 15,1 / 25,4 ms.
Counters mais estáveis comprimem melhor para todos os engines, e a ordem não muda.
Um segundo par de execuções pôs blocos de 15 minutos no Prometheus e no engine sobre 2 h de
tempo virtual, 9,6 M de amostras (bench/runs/2026-09-22-20k-2h-15mblocks-steady.md e
...-15mblocks-bursty.md). Blocos selados: 3,58x e 3,28x contra o Prometheus, 1,18x e 1,22x
contra o VictoriaMetrics. O ingest contra o VictoriaMetrics é de 0,98x na execução estável,
uma derrota, e 1,06x na execução em rajadas. P50 de consulta, os três engines em ordem: 66,0 / 10,0 /
12,0 ms no perfil estável e 65,5 / 10,0 / 13,0 ms no perfil em rajadas. O Prometheus é o menor dos três em RAM
ali, 87 e 91 MiB contra os 122 e 121 do engine: blocos de quinze minutos mantêm o head dele
curto, enquanto o VictoriaMetrics dimensiona os caches dele a partir da memória da máquina, e
não a partir dos dados, então um conjunto pequeno não o deixa pequeno (176 e 213 MiB). Blocos
curtos custam ao
Prometheus overhead de índice por bloco, e é por isso que os números de 2 h acima são os que o
CLAIMS.md imprime: são os que favorecem o Prometheus.
Leia as duas linhas de disco assim. Blocos selados são o regime permanente: quanto o disco custa por amostra depois que o write-ahead log foi checkpointado e o head foi persistido. Esse é o 2,9x contra o Prometheus e o 1,2x contra o VictoriaMetrics. A linha do diretório inteiro é um retrato durante o ingest: o Prometheus mantém as últimas duas a três horas em um write-ahead log a cerca de 20 bytes por amostra, o VictoriaMetrics já tinha sido descarregado e mesclado, e o WAL do engine fica vazio depois de um selamento. Essa razão contra o Prometheus é real enquanto os dados estão chegando e diminui conforme a retenção cresce, então ela é impressa apenas aqui e apenas com "durante o ingest" ao lado.
Onde o engine ainda perde. Três linhas destas execuções, e elas são impressas onde quer que as vitórias delas estejam; o soak abaixo acrescenta uma quarta, o diretório de dados enquanto os dados estão no head.
O VictoriaMetrics responde à consulta de 20.000 séries 1,5x mais rápido no p50 e 1,7x no p90 (16 ms contra 24, 20 contra 33). Com 200.000 ele é 1,3x mais rápido que o engine com o cache de resposta dele e 1,4x mais lento sem ele, porque o trabalho ali é dominado pelas séries que a consulta toca e o avaliador coluna a coluna reduz cada uma em uma única passada. O que sobra com 20.000 é custo fixo por consulta, e não trabalho por amostra.
O RSS com 200.000 séries está 64% acima do VictoriaMetrics (511 MiB contra 312). O head mantém um chunk aberto por série no heap Go e manda os fechados para o spill; o VictoriaMetrics quase não guarda nada em memória e lê das parts dele.
O ingest com 20.000 séries é paridade, não vitória (555k contra 567k, 0,98x). Com 200.000 o engine está à frente, 582k contra 520k.
Rodadas do engine: o que mudou entre os relatórios
A rodada 1 foi o caminho de leitura, a rodada 2 o caminho de escrita e a memória que ele
custa. O Prometheus e o VictoriaMetrics foram medidos de novo ao lado do engine em cada sessão,
então as colunas deles também mostram quanto vale o ruído desta máquina compartilhada. Os
relatórios chamados *-before-engine-round1.md em bench/runs/ são o engine como ele estava
antes de tudo isso, medido na mesma sessão que os da rodada 1.
Só dois estados do engine têm relatórios em bench/runs/, então só esses dois recebem
números: *-before-engine-round1.md, o engine como ele estava antes de todo este trabalho, e
as duas execuções em rajadas de que as tabelas acima vieram. O par estável de antes e depois é
com 20.000 séries sobre 4 h e com 200.000 sobre 2 h; a coluna "entregue" é o perfil em rajadas,
então leia cada linha contra as colunas de engine dela e não entre os dois pares. O p50 de
20.000 séries entregue é o número corrigido, medido só sobre as respostas.
| antes da rodada 1 (estável) | Prom | VM | entregue (em rajadas) | Prom | VM | |
|---|---|---|---|---|---|---|
query_range p50, 20k | 104,2 ms | 110,0 | 16,6 | 24,3 ms | 97,1 | 15,9 |
query_range máximo, 20k | 577,5 ms | 133,7 | 48,1 | 102,2 ms | 152,1 | 32,6 |
query_range p50, 200k | 1.281,5 ms | 747,6 | 60,6 | 67,7 ms | 505,9 | 53,5 |
query_range máximo, 200k | 4.316,7 ms | 1.544,6 | 219,2 | 258,5 ms | 608,2 | 248,0 |
| Ingest, 20k | 436.131/s | 379.425 | 453.422 | 554.670/s | 467.338 | 566.680 |
| Ingest, 200k | 376.004/s | 338.722 | 387.317 | 581.530/s | 429.263 | 520.218 |
| RSS, 200k | 1.017 MiB | 750 | 325 | 511 MiB | 856 | 312 |
| Heap vivo, 200k | 825 MiB | 406 | 210 | 288 MiB | 592 | 218 |
| Disco por amostra, selado, 20k | 1,676 B | 5,232 | 2,062 | 1,871 B | 5,381 | 2,243 |
O trabalho entre esses dois estados veio em rodadas, e o que cada rodada fez está abaixo. As
medições intermediárias foram tiradas com o mesmo script, mas os arquivos results.md delas
não foram guardados, então elas não trazem números aqui.
Rodada 5, o spill de chunks do head. Os chunks fechados de uma série passaram a ser
escritos em um arquivo mapeado em memória sob o diretório de dados, em vez de ficarem no heap
Go, e o head passou a guardar apenas o chunk aberto por série. Contra o relatório de antes da rodada 1, com
200.000 séries isso é o RSS de 1.017 para 511 MiB e o heap vivo de 825 para 288 MiB, que é o
que colocou o engine abaixo do Prometheus nessa escala. Aquele spill crescia 8 MiB por
vez e era apagado quando o head era selado, e o run.sh lê o diretório de dados depois do
selamento, então ali o diretório eram os blocos mais um write-ahead log curto, e a linha de
disco do diretório inteiro continuava sendo uma vitória. O soak abaixo lê o diretório
enquanto os dados ainda estão no head, e ali ele é uma derrota. O spill foi redesenhado duas
vezes depois desses relatórios. Primeiro os segmentos passaram a ser lidos com pread e
nunca mapeados, com cada série gravando em extensões de 2 KiB só dela; é o build que o soak
abaixo mediu. Agora os chunks de todas as séries são empacotados em segmentos compartilhados
com cerca de 11 bytes de cabeçalho cada, o WAL grava os labels de cada série uma vez por
arquivo e os blocos são compactados em segundo plano (o orbit-stack.md tem o desenho).
Nenhum relatório em bench/runs/ mede o build atual ainda, então todo número de engine desta
página é de um dos dois builds anteriores, e cada um diz de qual.
Rodada 4, o avaliador. rate, increase, delta e irate sobre um seletor de
intervalo, sozinhos ou sob um único sum/avg/min/max/count, são computados série a
série: uma passada por série preenche todos os passos, os fins de janela são cursores em
vez de buscas binárias, o grupo de uma série é resolvido uma vez em vez de a cada passo, e
nenhum vetor por passo é construído. Qualquer outra coisa cai no avaliador geral. Os testes de equivalência pegaram dois bugs de
associatividade de float antes de irem para produção (uma soma de prefixos sobre resets de
counter e agregados parciais por worker), e os dois agora são somados na ordem do avaliador geral, então as respostas são os mesmos bits, e não
apenas iguais até o décimo quinto dígito. O internal/promql/columnwise_test.go (no engine em
Go, tag go-oracle) roda toda
expressão nomeada na suíte de PromQL, mais séries aleatórias com resets, lacunas e NaN, pelos
dois avaliadores e compara amostra por amostra. Os dois também foram comparados sobre um
diretório real de 200.000 séries, diferenciando as respostas dos dois builds, que bateram byte
a byte; essa foi uma checagem pontual sem artefato guardado, então ela não traz número aqui.
Rodada 3, o formato de bloco. As colunas de um bloco selado não são mais um único stream
zstd: são frames independentes de 4.096 séries, o índice registra onde cada frame está e onde
cada série fica dentro do frame dela, e uma consulta descomprime, em paralelo, apenas os
frames em que os matchers dela caem, para um cache de processo limitado por
ORBIT_STACK_BLOCK_CACHE_BYTES. A largura troca disco por velocidade e foi medida: um
frame zstd começa o contexto dele do zero, então frames estreitos custam compressão. A largura foi
escolhida varrendo-a com 20.000 séries e lendo disco por amostra contra a primeira consulta
depois de um selamento: frames estreitos custam sensivelmente mais disco por um pouco mais de
velocidade, e 4.096 foi o ajuste mais largo que ainda cortava a leitura fria. Essa varredura
usou o mesmo script, mas os arquivos results.md dela não foram guardados, então nenhum
número dela é impresso aqui. O formato é versionado: este build escreve v3, que faz checksum
do índice dele e de cada frame, e ainda abre um bloco v1 ou v2, lendo-o sem verificação e
contando-o em orbit_stack_unverified_blocks; um v1 abre como o frame único que ele é.
Há testes para cada um e para uma versão que ele não consegue ler.
Rodada 2, o caminho de escrita. O decodificador de remote-write recorta conjuntos de
labels e amostras de arenas que ele mantém entre requisições e interna todo nome e valor
dentro de uma requisição; o head interna de novo entre requisições, então uma string
instance é compartilhada pelas noventa séries daquela instância; uma amostra de uma série
que já existe não custa alocação alguma; os buffers de registro e de compressão do WAL são
mantidos em pool; e os chunks do head crescem de um oitavo por vez em vez de por append, o
que estava deixando um terço do head em folga. O BenchmarkIngestRequest, em
internal/tsdb, mede quanto uma requisição de 5.000 amostras aloca, e foi com ele que a
mudança foi julgada; é um benchmark Go, go test -bench, e não uma execução do
bench/run.sh, então os números dele não são impressos aqui. Em uma execução inteira o efeito aparece na linha que todo relatório imprime
sob a tabela dele, o total de objetos que o processo alocou. Isso comprou as linhas de ingest e um quinto do heap vivo; não comprou a linha de
RSS, porque a linha de RSS nunca foi churn de alocação.
O que é a linha de RAM com 200k. Desde o spill, o heap Go guarda um chunk aberto por série viva, mais os labels daquela série e o lugar dela no índice invertido; todo chunk que a série fechou estava no arquivo mapeado em memória, e agora está nos segmentos do spill. O que o relatório entregue de 200.000 séries imprime é 511 MiB residentes com 288 MiB de heap vivo enquanto o head está cheio, e 77 MiB residentes assim que o head é selado. A diferença entre esses dois é o que um head cheio custa. Isso escala com séries vivas, e não com as amostras que elas guardam, e é por isso que a duração do bloco não move mais esse número.
O replay agora é limitado. Um pod que reinicia depois de o write-ahead log dele ter
crescido por horas costumava reprocessar tudo para dentro do head e segurar aquilo: isso é um
OOMKill em um limite de 1 GiB, e aconteceu no k3d. O replay decodifica registro por registro
em buffers reaproveitados e, quando o que ele reprocessou abrange mais de uma duração de
bloco, o head é selado antes de a primeira requisição ser servida, com o intervalo e o
selamento no log. O TestReplayWiderThanABlockSealsOnOpen reprocessa três horas contra uma
janela de trinta minutos e falha se o head ainda estiver segurando aquilo.
O soak do prometheus-benchmark
O services/rust/orbit-stack/bench/soak.sh roda a carga do VictoriaMetrics/prometheus-benchmark
em um commit fixado: node_exporter 1.4.0 atrás de um cache de 1 s, multiplicado em tantos
alvos quanto a escala pede, coletado a cada 10 s pelo vmagent, que troca os labels de uma
fatia dos alvos a cada poucos minutos (churn de séries) e faz remote-write para o engine
testado, enquanto o vmalert avalia as 40 regras de alerta do chart contra ele a cada 10 s. Os
componentes do chart rodam como binários de release com checksum conferido ao lado dos
engines, e não no k3d, e cada engine roda no seu próprio scope do systemd, com um teto de
memória e um conjunto de CPUs; o summary.md da execução lista cada desvio em relação ao
chart. Ele mede, por escala, bytes selados por amostra, o diretório de dados inteiro por
amostra aceita enquanto os dados estão vivos, RSS (mediana estável e pico), ingest
sustentado, CPU por amostra, uma rajada de ingest máximo e a latência das regras e da
consulta de continuidade.
- O modo par (
soak.sh pair <scale> <reps>, e as células de par doofficial) roda o Orbit Stack e o VictoriaMetrics ao mesmo tempo atrás de um único vmagent, de modo que os dois recebem bytes idênticos, cada um com o mesmo teto de memória e um conjunto de CPUs que não divide nenhum núcleo físico com o do outro; os dois conjuntos trocam de lado a cada repetição. - A passada do Prometheus vem depois de cada célula de par (
PAIR_PROM=1, o default): o Prometheus sozinho, com a mesma agenda de churn, os mesmos alvos, a mesma seed de rajada e as mesmas regras de teto. Os valores do node_exporter são ao vivo, então a entrada dele bate com a do par no formato, e não byte a byte. - O
recheckrepetia a consulta de continuidade do jeito que o primeiro benchmark a rodou (a mesma rajada, um flush, depois a consulta em sequência com o limitador de leituras padrão de cada binário) contra o binário do loop 1 e o atual, alternando a ordem deles a cada repetição, e guardava o status de cada resposta, de modo que a medição de um429se distinguia da medição de uma resposta. Foi assim que se descobriu que a linha de consulta com 20.000 séries acima incluía recusas, e ela foi corrigida. Ele compilava o engine em Go do loop 1, então saiu do script junto com o Go em 2026-10-19. - Perfis:
official(10 minutos de aquecimento e 2 h medidas por célula),quick(5 minutos e 30 minutos, só direção) esmoke(prova o harness, nunca é resultado).VALUES=diversedá a cada alvo os próprios valores, porque alvos clonados comprimem bem demais para ser realista; oofficialroda um par diverso ao lado de cada par do chart e se recusa a começar em uma máquina que osoak.sh quietnão considere ociosa.
A única execução dele no repositório até agora é bench/runs/2026-09-23-pb-quick-pair/: o
perfil quick, três repetições do par em cada escala, sem passada do Prometheus, em uma
máquina ocupada (o relatório imprime a carga de cada repetição). Ela mediu o engine como
estava em dd0e579, com um patch do limitador que o relatório nomeia, anterior ao WAL, ao
spill e à compactação desta release. Leia-a só como direção. As células são VictoriaMetrics
/ Orbit Stack, medianas de três repetições, com o Orbit Stack dividido pelo VictoriaMetrics;
abaixo de 1 é melhor para o engine.
| Medida | 20.000 séries | 200.000 séries | 1.000.000 séries |
|---|---|---|---|
| Bytes selados por amostra | 2,742 / 0,547 (0,20x) | 2,472 / 0,463 (0,19x) | 2,741 / 0,364 (0,13x) |
| Diretório de dados inteiro por amostra aceita, ao vivo | 2,648 / 27,112 (10,24x) | 2,465 / 23,966 (9,72x) | 2,739 / 23,965 (8,75x) |
| Mediana estável de RSS, MiB | 95 / 42 (0,44x) | 266 / 173 (0,65x) | 880 / 678 (0,77x) |
| Pico de RSS, MiB | 124 / 50 (0,41x) | 406 / 207 (0,51x) | 1.334 / 793 (0,59x) |
| CPU do engine por amostra, µs | 12,57 / 7,38 (0,59x) | 6,73 / 4,62 (0,69x) | 6,60 / 4,84 (0,73x) |
| Ingest máximo, amostras/s | 607.145 / 529.343 (0,87x) | 546.969 / 558.503 (1,02x) | 515.626 / 557.130 (1,08x) |
| p50 das regras, ms | 1,29 / 0,79 (0,61x) | 5,86 / 3,10 (0,53x) | 23,44 / 15,42 (0,66x) |
| p99 das regras, ms | 8,99 / 5,41 (0,60x) | 71,78 / 38,11 (0,53x) | 398,55 / 188,99 (0,47x) |
Os dois engines acompanharam a carga oferecida em todas as repetições, então o ingest
sustentado é empate. O ingest máximo também é empate: o VictoriaMetrics ficou à frente nas
três repetições com 20.000 séries, e as faixas se sobrepõem nas outras duas escalas. As
faixas do p99 das regras com 20.000 séries também se sobrepõem. A linha de bytes selados sai
inflada para os dois engines por causa dos alvos clonados, e é para isso que existe o
VALUES=diverse.
A derrota: o diretório de dados enquanto os dados estão no head, de 8,75x a 10,24x os
bytes por amostra do VictoriaMetrics. Duas coisas a causaram: o WAL registrava cada
requisição de remote-write com os conjuntos de labels completos, e o spill gravava os chunks
curtos de cada série em uma extensão de 2 KiB só dela. Esta release reescreveu as duas:
séries gravadas uma vez por arquivo de WAL, colunas de amostras em deltas e XORs, chunks
empacotados em segmentos compartilhados. Nenhum relatório em bench/runs/ mede o
resultado ainda.
Traces contra o Grafana Tempo
Rodada 2, executada de novo por um crítico independente. Relatório:
services/rust/orbit-stack/bench/runs/2026-09-24-traces-vs-tempo.md, seção "Round 2, re-run by
an independent critic", com os resumos do crítico em
bench/runs/2026-09-24-traces-vs-tempo/round2-critic/. O crítico executou de novo, às cegas,
o build da rodada 2 com o método do bench/traces.sh: os dois engines no ar ao mesmo tempo,
leituras intercaladas repetição a repetição, o Tempo com -target=all, com os processadores
de span-metrics e de service-graphs gravando num Prometheus v3.1.0 e os limites elevados, e o
Tempo lido do jeito que o Grafana lê (um trace por id em protobuf, as consultas de um painel
ao mesmo tempo). Cargas: 50.000 traces no formato da loja mais um de 10.000 spans (3
rodadas), 300.000 traces = 3,4 M de spans (1 rodada) e 20.000 traces inteiros no head (2
rodadas); p50 de 20 repetições, medianas entre rodadas. A máquina era compartilhada: médias
de carga de 14 a 35 em 12 CPUs. As correções da rodada 3 (um teto de memória, o pareamento do
service graph) não passaram por benchmark: estes são os números da rodada 2.
Retirados, e nunca impressos aqui: a razão de trace por id da rodada 1, que comparava o
caminho JSON do Tempo; a afirmação da rodada 1 de que nenhuma linha de trace era derrota; a
primeira razão da própria rodada 2 sobre 200 ids, que lia 20 ids; a primeira razão de ingest
da própria rodada 2 com 50.000 traces, que a nova execução não reproduziu; e toda razão de
resumo de serviços e de mapa de serviços com 3,4 M de spans, porque ali as respostas dos dois
engines estavam incompletas: as span metrics do Tempo guardavam só uma parte dos spans, e o
service graph do Orbit Stack descartava pareamentos num teto fixo que a rodada 3 transformou
em configuração (ORBIT_STACK_TRACE_GRAPH_PENDING).
Vitórias e derrotas são impressas juntas. Cada linha da primeira tabela se lê com a segunda tabela ao lado.
| Número | Grafana Tempo 3.0.0 | Orbit Stack | Razão |
|---|---|---|---|
| Trace por id, um trace de 10.000 spans, p50 (50.000 traces) | 363 ms (protobuf) | 38 ms | 9,5x mais rápido |
| Trace por id, traces de 10 spans, p50 sobre 200 ids (50.000 traces) | 40,6 ms | 0,90 ms | 45x mais rápido |
| Busca por valores comuns (serviço; erro; serviço e duração; atributo), modo padrão do Tempo, 50.000 traces | 19,9 / 23,1 / 22,8 / 35,3 ms | 1,13 / 1,02 / 1,11 / 1,18 ms | 18x a 30x mais rápido |
| As mesmas buscas com 3,4 M de spans | 19,0 / 47,6 / 38,0 / 73,6 ms | 1,56 / 1,59 / 1,46 / 1,94 ms | 12x a 38x mais rápido |
| Ingest aceito, spans/s (50.000 traces; 3,4 M de spans) | 197.481; 55.186 | 269.185; 257.594 | 1,4x; 4,7x |
| Memória do contêiner 45 s após o ingest (50.000 traces; 3,4 M de spans) | 680 MiB; 2.102 MiB | 356 MiB; 263 MiB | 1,9x; 8,0x menos |
| Resumo de serviços (taxa, erros, p50/p95/p99, pods por serviço), p50, 50.000 traces | 4,04 ms (PromQL sobre as séries do generator dele); 6,73 ms (TraceQL metrics) | 2,92 ms | 1,4x; 2,3x mais rápido |
| Mapa de serviços, p50, 50.000 traces | 4,32 ms (PromQL sobre as séries do generator dele) | 3,20 ms | 1,4x mais rápido |
| Componentes a operar para ter traces com mapa de serviços | 2 (Tempo e Prometheus) | 1 | n/a |
| Derrota | Grafana Tempo 3.0.0 | Orbit Stack | Razão |
|---|---|---|---|
| Busca por um valor de atributo que um único trace tem, 3,4 M de spans | 11,2 ms | 677 ms | 60x mais lento |
| Busca por um valor de atributo que nenhum trace tem, 3,4 M de spans | 9,0 ms | 623 ms | 69x mais lento |
| Busca por um status ausente em um único serviço, 3,4 M de spans | 105 ms | 544 ms | 5,2x mais lento |
Resumo de serviços, a primeira leitura logo depois de um /-/flush, tudo no head | 4,0 ms | 24,5 / 30,5 ms (2 rodadas) | 6x a 8x mais lento |
Mapa de serviços, a primeira leitura logo depois de um /-/flush, tudo no head | 4,0 ms | 16,3 / 67,6 ms (2 rodadas) | 4x a 17x mais lento |
As vitórias de busca valem só para valores comuns. Uma vitória de busca vale para valores que são comuns nos dados recentes: a busca lê os resumos do mais novo para o mais antigo e para quando já tem o bastante. Um valor raro ou ausente faz com que ela leia todos os resumos da janela, e com 3,4 M de spans isso é de 5x a 69x mais lento que o Tempo, como mostra a tabela de derrotas. Com 50.000 traces, a mesma busca por um valor raro é 2,6x mais rápida.
Em 2026-10-03 a busca por valor raro passou a pular todo trace dividido e todo chunk de resumo que os blooms de atributo descartam: com 1,13 M de spans, a busca por atributo raro foi de 447 para 8,0 ms (a seção de 2026-10-03). Ela não foi executada de novo com 3,4 M de spans, então as linhas de derrota acima continuam valendo até que seja.
Mais recentes primeiro. O modo padrão do Tempo devolve os resultados que ele encontra
primeiro; quando se pede os mais recentes (most_recent=true), que é o que a busca do Orbit
Stack sempre devolve, o Tempo fica de 30x a 689x mais lento. Essa comparação vai ao lado das
linhas do modo padrão acima, nunca no lugar delas.
A primeira leitura depois de um flush. O resumo de serviços e o mapa de serviços lidos
logo depois de um /-/flush são mais lentos que a mediana do Tempo: o flush também sela o
head de métricas, então eles viram a primeira consulta PromQL sobre um bloco recém-selado (as
duas últimas linhas da tabela de derrotas).
Disco não é afirmado: quando foi medido, os dados do Tempo eram o write-ahead log e o live-store dele, não blocos compactados. Estas tabelas vêm de uma única máquina compartilhada, sob a carga que ela tinha; uma nova execução numa máquina quieta as substitui, em vez de entrar numa média com elas.
Ambiente
Os relatórios do run.sh acima: uma máquina, os três engines em sequência:
- AMD Ryzen 5 5500, 12 threads, 31 GiB de RAM, WSL2 (Linux 6.6), diretórios de dados no sistema de arquivos ext4 raiz da distribuição (um par anterior de execuções no drive Windows montado via 9p deu os mesmos números de disco e I/O mais lento nos dois lados).
- Prometheus 3.1.0 a partir de
prom/prometheus:v3.1.0no Docker, com--web.enable-remote-write-receiver,--storage.tsdb.min-block-duration=2h --storage.tsdb.max-block-duration=2h, sem alvos de scrape, de modo que toda amostra armazenada foi uma amostra enviada pelo gerador. - VictoriaMetrics single-node v1.152.0 a partir de
victoriametrics/victoria-metrics:v1.152.0no Docker, com-storageDataPathem um volume montado,-retentionPeriod=30d, e todo o resto nos defaults, o que inclui o cache de resposta dele e a reserva de memória padrão dele. O disco dele é lido depois quePOST /internal/force_flushePOST /internal/force_mergeterminaram, o que o script espera fazendo polling devm_active_mergesevm_pending_rowsaté zero. - Orbit Stack construído a partir deste repositório, executado como binário puro, com
ORBIT_STACK_BLOCK_DURATION=2h,ORBIT_STACK_COMPRESSION=better(zstd) e autenticação desligada durante a execução.
Os dois engines em Docker levam docker rm -f antes de a próxima execução começar, então nada
de uma execução está vivo durante a seguinte.
O disco é du -sb em cada diretório de dados depois que a execução assentou: o Prometheus
depois que a compactação do head dele cortou o bloco de 2 h (o script espera por isso), o
VictoriaMetrics depois do flush e do merge dele, e o Orbit Stack depois que POST /-/flush
selou o head. As amostras em blocos vêm dos metadados do próprio bloco para o Prometheus e o
Orbit Stack; o VictoriaMetrics não tem esses metadados, então o diretório data/ dele (small
parts, big parts e indexdb) é dividido pelas amostras enviadas, e o relatório registra
quantos bytes de índice ainda estavam em memória naquele momento. O RSS é o VmRSS do
processo do engine e o docker stats para os dois contêineres, lido logo após o ingest (no
caso do Prometheus, depois da espera pela compactação do head dele, já que essa espera é o que
coloca o bloco dele em disco, então o número dele é o tirado mais tarde). A latência de consulta
são 60 chamadas sequenciais de query_range de
sum by (instance) (rate(node_cpu_seconds_total{mode="user"}[5m])) sobre a janela inteira
com passo de 60 s, cronometradas pelo curl.
Esta máquina é compartilhada com outros trabalhos. Todo relatório registra a carga média de um minuto que viu no ingest de cada engine e no loop de consultas, em 12 núcleos. As duas execuções de que as tabelas acima vieram foram tiradas em uma máquina ociosa: as cargas que esses relatórios imprimem vão de 1,82 a 11,38 nas doze leituras de fase deles. Relatórios anteriores no mesmo diretório foram tirados enquanto a máquina estava mais ocupada e imprimem cargas maiores, e é por isso que os números absolutos deles são menores; os três engines foram medidos com minutos de diferença sob carga comparável, e uma execução cujas três fases viram cargas muito diferentes não é comparável entre engines e diz isso no próprio relatório dela.
Carga de trabalho
O orbit-bench (services/rust/orbit-tools) gera os dados. Ela é sintética, determinística (uma
mesma seed produz os mesmos bytes para todos os engines e, em amd64, os mesmos bytes que o
original em Go, cmd/orbit-bench na tag go-oracle), roda na entropia padrão do script,
de -noise 0.3, e tem o formato do que um node Kubernetes exporta: 94 séries por
instância, percorrendo nomes de métricas do node_exporter, do cAdvisor e do
kube-state-metrics com os formatos reais de valor.
| Formato | Exemplos | Parcela |
|---|---|---|
| Counters inteiros com taxa ruidosa | bytes de rede e de disco, restarts, buckets de histograma | 28% |
| Counters com duas casas decimais | node_cpu_seconds_total por cpu e por modo | 17% |
| Counters float de precisão plena | container_cpu_usage_seconds_total | 6% |
| Gauges inteiros em passeio aleatório | memória, filesystem, load average, RSS, goroutines | 15% |
| Booleanos que raramente mudam | kube_pod_status_phase | 6% |
| Constantes ou zero | limits, tamanhos, contagens de réplica, counters de erro e de descarte, up | 28% |
Todas as séries de uma instância carregam o mesmo timestamp de scrape, com um jitter de
±20 ms por scrape e uma fase por instância dentro do intervalo, do jeito que um scraper se
comporta. A flag -noise define a dispersão relativa de cada incremento de counter: 0,3
(em rajadas) e 0,05 (estável) são os dois perfis reportados. Ela é o parâmetro de ajuste da entropia da carga
de trabalho e é a principal ressalva desta página: nenhum codec vence a entropia de um
incremento aleatório, então a razão entre os engines depende mais de quão ruidosas são as suas
métricas do que de qualquer um deles. Um parque com muitos nodes ociosos e counters estáveis
fica acima destes números; um parque de serviços quentes com counters float de precisão plena
fica abaixo deles.
Reproduza
# From the repository root. Needs cargo, Docker and ~4 GiB of free disk.# The Results tables came from the Go engine (tag go-oracle), which this repository# no longer builds; these two commands run the same two workloads on the Rust engine.# The entropy knob is left at the script's default, counter noise 0.3. The script# now defaults to a newer Prometheus, so the image is pinned to the one measured.PROM_IMAGE=prom/prometheus:v3.1.0 SERIES=20000 SPAN=4h BLOCK=2h services/rust/orbit-stack/bench/run.shPROM_IMAGE=prom/prometheus:v3.1.0 SERIES=200000 SPAN=2h BLOCK=2h QUERIES=10 services/rust/orbit-stack/bench/run.shA comparação de traces com o Grafana Tempo (precisa de cargo, Docker, python3 e um
diretório de saída vazio em ext4, por padrão sob $TMPDIR ou /tmp):
services/rust/orbit-stack/bench/traces.sh # 50,000 traces, 3 roundsTRACES=300000 ROUNDS=1 services/rust/orbit-stack/bench/traces.sh # 3.4 M spans, 1 roundTRACES=20000 ROUNDS=2 services/rust/orbit-stack/bench/traces.sh # all in the head, 2 roundsO soak do prometheus-benchmark:
# From services/rust/orbit-stack. Needs cargo, python3, systemd and an ext4 BENCH_ROOT# (default /tmp/orbit-bench); `plan` prints the free memory each scale needs.bench/soak.sh fetchbench/soak.sh planPROFILE=quick bench/soak.sh pair 200k 3O plan imprime cada célula da sequência oficial com o teto de memória dela, a memória livre
de que precisa e o tempo de relógio, e o official a executa. Cada execução do run.sh imprime a tabela dela e deixa o material bruto em
services/rust/orbit-stack/bench/results/<timestamp>-s<series>-n<noise>/: os três diretórios de
dados, o JSON do gerador para cada engine, o /api/v1/status/tsdb do engine, o /metrics do
VictoriaMetrics, as cronometragens de consulta e o results.md. Mude uma variável por vez.
SERIES e SPAN dimensionam a execução; BLOCK precisa ser o mesmo dos dois lados que têm
blocos, ou a comparação deixa de significar alguma coisa.
Regras de escopo que esta página protege
- A razão de disco é por amostra em blocos selados. Nunca a transporte para RAM.
- O número de ingest é throughput aceito por um engine em uma máquina, não um teto, e o VictoriaMetrics aceita mais rápido do que este engine.
- "1 binário" é o engine; a plataforma são quatro contêineres. O VictoriaMetrics single-node também é um binário, então essa frase é uma comparação com uma stack Prometheus e com mais nada.
- Um número que não esteja em um relatório versionado em
bench/runs/não vai para uma página: nem um benchmark Go, nem uma execução do próprio builder. - Uma execução
quickdo soak dá direção, não veredito, e uma execução em máquina ocupada diz isso no próprio relatório; os números oficiais vêm do perfilofficialem uma máquina ociosa.
Para onde ir em seguida
- O engine em si, seus endpoints e seus parâmetros de ajuste:
orbit-stack.md. - Os números como o site os imprime, com o escopo de cada um:
CLAIMS.md.