Pular para o conteúdo

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 novoAntesDepoisConcorrente na mesma execução
Busca de trace por um atributo que um único trace tem, 1,13 M de spans, p50447 ms8,0 msnenhum
Busca de trace por um atributo que nenhum trace tem, 1,13 M de spans, p50427 ms6,1 msnenhum
PromQL rate(...[5m]) com resposta de 3,5 MB, 20 mil séries, p5019,1 ms11,2 msnenhum
PromQL sum by (instance) (rate(...[5m])), 20 mil séries, p507,9 ms5,3 msnenhum
orbit-collector, traces por gRPC a ~44 mil spans/s, cores de CPU0,36 a 0,390,25 a 0,26otelcol-contrib 0.161.0: 0,49 a 0,59
orbit-collector, traces por HTTP, cores de CPU0,33 a 0,350,23otelcol-contrib: 0,55 a 0,69
orbit-collector, RSS9 MiB10 MiBotelcol-contrib: 219 a 221 MiB
orbit-agent, 500 mil séries, RSS estável257 MB90 a 93 MBnenhum

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.

MedidaPrometheus 3.1.0VictoriaMetrics v1.152.0Orbit Stackvs Prometheusvs VictoriaMetrics
Disco por amostra, blocos selados5,38 B2,24 B1,87 B2,9x1,2x
Disco por amostra, diretório de dados inteiro11,45 B2,24 B1,87 B6,1x1,2x
Ingest aceito, amostras/s467k567k555k1,19x0,98x (paridade)
RSS com o head cheio (20k séries x 4 h)257 MiB263 MiB105 MiB2,4x menos2,5x menos
Heap Go vivo naquele instante165 MiB181 MiB46 MiB3,6x menos4,0x menos
RSS depois de o head ser selado em blocon/an/a29 MiBn/an/a
query_range p50 / p90 em 60 execuções, só respostas97 / 108 ms16 / 20 ms24 / 33 ms4,0x / 3,3x mais rápida1,5x / 1,7x mais lenta
query_range máximo (a primeira consulta carrega os frames em que ela cai)152 ms33 ms102 ms1,5x mais rápidamais lenta
Erros de escrita000n/an/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)PromVMentregue (em rajadas)PromVM
query_range p50, 20k104,2 ms110,016,624,3 ms97,115,9
query_range máximo, 20k577,5 ms133,748,1102,2 ms152,132,6
query_range p50, 200k1.281,5 ms747,660,667,7 ms505,953,5
query_range máximo, 200k4.316,7 ms1.544,6219,2258,5 ms608,2248,0
Ingest, 20k436.131/s379.425453.422554.670/s467.338566.680
Ingest, 200k376.004/s338.722387.317581.530/s429.263520.218
RSS, 200k1.017 MiB750325511 MiB856312
Heap vivo, 200k825 MiB406210288 MiB592218
Disco por amostra, selado, 20k1,676 B5,2322,0621,871 B5,3812,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 do official) 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 recheck repetia 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 um 429 se 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) e smoke (prova o harness, nunca é resultado). VALUES=diverse dá a cada alvo os próprios valores, porque alvos clonados comprimem bem demais para ser realista; o official roda um par diverso ao lado de cada par do chart e se recusa a começar em uma máquina que o soak.sh quiet nã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.

Medida20.000 séries200.000 séries1.000.000 séries
Bytes selados por amostra2,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 vivo2,648 / 27,112 (10,24x)2,465 / 23,966 (9,72x)2,739 / 23,965 (8,75x)
Mediana estável de RSS, MiB95 / 42 (0,44x)266 / 173 (0,65x)880 / 678 (0,77x)
Pico de RSS, MiB124 / 50 (0,41x)406 / 207 (0,51x)1.334 / 793 (0,59x)
CPU do engine por amostra, µs12,57 / 7,38 (0,59x)6,73 / 4,62 (0,69x)6,60 / 4,84 (0,73x)
Ingest máximo, amostras/s607.145 / 529.343 (0,87x)546.969 / 558.503 (1,02x)515.626 / 557.130 (1,08x)
p50 das regras, ms1,29 / 0,79 (0,61x)5,86 / 3,10 (0,53x)23,44 / 15,42 (0,66x)
p99 das regras, ms8,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úmeroGrafana Tempo 3.0.0Orbit StackRazão
Trace por id, um trace de 10.000 spans, p50 (50.000 traces)363 ms (protobuf)38 ms9,5x mais rápido
Trace por id, traces de 10 spans, p50 sobre 200 ids (50.000 traces)40,6 ms0,90 ms45x mais rápido
Busca por valores comuns (serviço; erro; serviço e duração; atributo), modo padrão do Tempo, 50.000 traces19,9 / 23,1 / 22,8 / 35,3 ms1,13 / 1,02 / 1,11 / 1,18 ms18x a 30x mais rápido
As mesmas buscas com 3,4 M de spans19,0 / 47,6 / 38,0 / 73,6 ms1,56 / 1,59 / 1,46 / 1,94 ms12x a 38x mais rápido
Ingest aceito, spans/s (50.000 traces; 3,4 M de spans)197.481; 55.186269.185; 257.5941,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 MiB356 MiB; 263 MiB1,9x; 8,0x menos
Resumo de serviços (taxa, erros, p50/p95/p99, pods por serviço), p50, 50.000 traces4,04 ms (PromQL sobre as séries do generator dele); 6,73 ms (TraceQL metrics)2,92 ms1,4x; 2,3x mais rápido
Mapa de serviços, p50, 50.000 traces4,32 ms (PromQL sobre as séries do generator dele)3,20 ms1,4x mais rápido
Componentes a operar para ter traces com mapa de serviços2 (Tempo e Prometheus)1n/a
DerrotaGrafana Tempo 3.0.0Orbit StackRazão
Busca por um valor de atributo que um único trace tem, 3,4 M de spans11,2 ms677 ms60x mais lento
Busca por um valor de atributo que nenhum trace tem, 3,4 M de spans9,0 ms623 ms69x mais lento
Busca por um status ausente em um único serviço, 3,4 M de spans105 ms544 ms5,2x mais lento
Resumo de serviços, a primeira leitura logo depois de um /-/flush, tudo no head4,0 ms24,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 head4,0 ms16,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.0 no 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.0 no Docker, com -storageDataPath em 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 que POST /internal/force_flush e POST /internal/force_merge terminaram, o que o script espera fazendo polling de vm_active_merges e vm_pending_rows até 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.

FormatoExemplosParcela
Counters inteiros com taxa ruidosabytes de rede e de disco, restarts, buckets de histograma28%
Counters com duas casas decimaisnode_cpu_seconds_total por cpu e por modo17%
Counters float de precisão plenacontainer_cpu_usage_seconds_total6%
Gauges inteiros em passeio aleatóriomemória, filesystem, load average, RSS, goroutines15%
Booleanos que raramente mudamkube_pod_status_phase6%
Constantes ou zerolimits, tamanhos, contagens de réplica, counters de erro e de descarte, up28%

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

bash
# 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.sh

A 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):

bash
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 rounds

O soak do prometheus-benchmark:

bash
# 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 3

O 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 quick do 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 perfil official em 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.