CS Fundamentals Trainer · Guias

Séries temporais e sistemas de muita escrita

Projetando para um fluxo constante de pequenas escritas: batching e COPY, compressão delta-of-delta e XOR, expiração de dados descartando partições, cardinalidade de labels, rollups e por que percentis não podem ser tirados em média.

36 min de leitura

Métricas, logs, cliques, leituras de sensores, ticks financeiros, eventos de jogos: alguns sistemas recebem um enorme fluxo constante de pequenas escritas e as leem principalmente de forma agregada, por intervalo de tempo. Eles têm uma forma diferente da usual "aplicação web com um banco de dados": os dados são majoritariamente de acréscimo (ninguém edita a leitura de CPU da terça passada), as linhas são minúsculas, a taxa de escrita é alta e constante, os dados antigos importam menos a cada dia e as consultas são coisas como "o percentil 99 da latência por serviço na última hora". Os hábitos de uso geral (um INSERT por evento, DELETE para expirar linhas antigas, uma métrica por id de usuário) falham rápido sob essa carga. Este guia mede o que dá errado e o que funciona, em um servidor PostgreSQL real e com um modelo da compressão que os bancos de séries temporais usam. Os scripts estão no apêndice.

Ele se apoia em motores de armazenamento (por que acrescentar é barato), observabilidade (o principal uso de dados de séries temporais) e replicação e particionamento.

1. O que torna a carga diferente

Um banco de dados de aplicação típicoUma carga de séries temporais
Escritasaleatórias: atualize este usuário, insira aquele pedidoacrescentar no instante atual, de milhares a milhões por segundo
Atualizações e exclusões de linhas antigascomunsquase nunca; os dados antigos são descartados em bloco por idade
Leituraspor chave, pequenaspor intervalo de tempo e agregação sobre muitas linhas
Valor dos dadospermanececai com a idade (recentes: precisos; antigos: resumidos)
Linhamuitas colunas, variadasum timestamp, uma identidade de série (nome + labels) e um número

Cada um desses pontos leva a uma decisão de design: agrupe as escritas em lotes, particione por tempo, comprima a regularidade, mantenha os dados antigos em forma resumida e tome cuidado com o número de séries distintas.

Diagram: The path of a metric from the application to a dashboard

2. Escritas: faça lotes ou pague por cada commit

A primeira lição é sobre como você escreve. Gravei as mesmas 50 000 amostras (timestamp, id da série, valor) em uma tabela PostgreSQL de quatro maneiras:

MétodoTempoLinhas por segundoRelativo
um INSERT por transação (autocommit)16,7 s3 0001
uma transação com 50 000 INSERTs de uma linha3,3 s15 0005 vezes
1 000 linhas por comando INSERT0,40 s125 00042 vezes
COPY0,12 s420 000140 vezes

Os mesmos dados e o mesmo banco de dados, e um fator de 140. Para onde isso vai?

Então o caminho de ingestão de um sistema assim é construído em torno de lotes: agentes juntam amostras por cerca de um segundo e as enviam juntas, uma fila absorve rajadas e workers gravam grandes lotes com COPY ou uma API em massa. Isso também dá backpressure: quando o banco de dados está lento, a fila cresce (visivelmente) em vez de a aplicação dar timeout (padrões de resiliência). Torne as escritas idempotentes (uma amostra é identificada por série e timestamp, de modo que um lote repetido sobrescreve ou é ignorado em vez de duplicar, veja idempotência), porque a entrega at-least-once é a garantia realista.

Os índices também custam a cada escrita. Uma tabela de séries temporais normalmente precisa de um índice em (série, tempo) ou só em tempo, não de cinco; cada índice extra deixa a ingestão mais lenta e a tabela maior.

3. Comprimindo uma série temporal

Os dados de séries temporais são incomumente compressíveis porque são regulares: os timestamps chegam em intervalos fixos, e valores consecutivos são próximos entre si. O artigo do Gorilla (Facebook, 2015) descreveu dois truques simples que hoje são usados, em variantes, pelo Prometheus, InfluxDB, TimescaleDB e outros:

Contei os bits de que essa codificação precisa em 100 000 amostras sintéticas (comparados com 16 bytes = 128 bits para um timestamp e um valor brutos):

SérieBits por amostraCompressão
um gauge que quase não muda2,064 vezes
um contador que aumenta de um em um16,47,8 vezes
um sensor, suave, uma casa decimal28,64,5 vezes
o mesmo com timestamps oscilando um segundo22,25,8 vezes
ruído aleatório com precisão total de ponto flutuante54,82,3 vezes

O padrão é o ponto. Timestamps regulares custam quase nada, valores que não mudam custam quase nada e o ruído não pode ser comprimido (a última linha guarda a maior parte dos bits de cada valor). Duas consequências práticas: alinhe a coleta a um intervalo fixo (timestamps com oscilação custam cerca de seis vezes mais bits só no timestamp) e não registre mais precisão do que precisa, já que arredondar um sensor para uma casa decimal transformou 54,8 bits em 28,6. O Facebook relatou uma média de 1,37 byte por amostra em seus dados de produção.

O armazenamento orientado a colunas ajuda do mesmo jeito: guardar todos os timestamps juntos, e todos os valores de uma série juntos, torna cada bloco uniforme, o que comprime bem e faz as varreduras de agregação lerem apenas as colunas de que precisam. Esse é o design do ClickHouse e da compressão do TimescaleDB.

4. Apagando dados antigos: particione por tempo

Os dados de séries temporais são mantidos por um período de retenção (30 dias de dados brutos, por exemplo) e depois removidos. No Postgres, o jeito óbvio é DELETE FROM samples WHERE ts < now() - interval '30 days'. Funciona, e é caro. Construí uma tabela de 5 000 000 de linhas cobrindo 10 dias, uma vez como tabela simples e outra particionada em uma partição por dia, e removi os dois dias mais antigos (1 000 000 de linhas):

DELETE em uma tabela simplesDROP de duas partições diárias
tempo0,8 a 1,3 s (duas execuções)54 ms
WAL gravado103 MB2,4 MB
tamanho da tabela depois356 MB (inalterado)285 MB (espaço liberado na hora)
trabalho extra depoisVACUUM FULL: 3,6 s e um lock exclusivo, para chegar a 285 MBnenhum

Um DELETE marca cada linha como morta, grava cada exclusão no WAL (que é também o que as réplicas recebem) e deixa o espaço no arquivo para reutilização posterior por um VACUUM comum; a tabela não encolhe em disco até haver uma reescrita. Descartar uma partição é apagar um arquivo: leva milissegundos, grava quase nada e devolve o espaço em disco na hora, qualquer que seja o número de linhas. A partição também ajuda as leituras. Para uma consulta sobre a última hora, o plano varreu apenas a partição do último dia (partition pruning), em 3,3 ms, e as outras nove partições não foram tocadas. E as partições recentes continuam pequenas, então seus índices cabem na memória, o que mantém as escritas quentes rápidas (hierarquia de memória).

O custo é operacional: as partições precisam ser criadas com antecedência (automatize isso, com alguns dias de margem para que um job que falhe não faça os inserts falharem), e as consultas e restrições únicas devem incluir a chave de partição. Extensões como o TimescaleDB automatizam isso ("hypertables" e "chunks"), e os bancos de dados criados para o propósito (blocos do Prometheus, shards do InfluxDB, partições do ClickHouse) funcionam do mesmo jeito: a expiração é a exclusão de intervalos de tempo inteiros, nunca de linhas individuais.

5. Cardinalidade: o número de séries é o tamanho real

Em um banco de dados de séries temporais, uma série é uma combinação única de um nome de métrica e valores de labels: http_requests{service="checkout", status="500", endpoint="/pay"}. O armazenamento e a memória dependem menos do número de amostras do que do número de séries distintas, porque cada série tem uma entrada de índice e um buffer em memória para suas amostras recentes. A contagem é o produto dos valores dos labels:

LabelsSériesMemória com 3 KB supostos por série
serviço (20) × código de status (5)100desprezível
× endpoint (50)5 00015 MB
× instância (30)150 000440 MB
× id de usuário (10 000 usuários)1 500 000 000cerca de 4 TB

Acrescentar um label com muitos valores transformou um sistema confortável em um impossível. A regra é: os labels precisam ter um conjunto pequeno e limitado de valores. Nunca use ids de usuário, ids de sessão, endereços de e-mail, URLs completas com ids ou ids de requisição como labels (use o template de rota /users/{id}, não /users/48213). Perguntas de alta cardinalidade ("o que este usuário fez?") pertencem a logs ou traces (observabilidade), que são projetados para serem pesquisados por campos arbitrários. Monitore o próprio número de séries ativas e alerte quando ele disparar; um deploy que acrescenta um label ilimitado é uma causa clássica de queda do monitoramento.

5.1 Um incidente de cardinalidade, passo a passo

Suponha que um servidor tenha 8 GiB reservados para séries, a 3 KiB por série como usado acima: espaço para cerca de 2,8 milhões de séries (cardinality.py). Hoje ele guarda 150.000 séries (o produto 20 × 5 × 50 × 30 da tabela). Um deploy adiciona um rótulo customer_id ao contador de requisições, "para que o suporte veja os erros de um cliente". O serviço atende 60.000 requisições por minuto de 400.000 clientes distintos, com alguns muito ativos e uma longa cauda de clientes raros, e simulei uma hora (o formato do tráfego é uma suposição minha):

Minutos após o deploySériesMemóriaParcela do limite
1208.7270,6 GiB7%
10677.4711,9 GiB24%
201.147.7703,3 GiB41%
402.023.5235,8 GiB72%
602.851.3568,2 GiB102%

O limite é ultrapassado no minuto 59. Nada parece errado durante a maior parte da hora, porque o número de séries cresce de forma suave e a taxa de amostras não muda; o crescimento também não é linear, porque os clientes muito ativos reutilizam séries enquanto a longa cauda cria séries novas o tempo todo, de modo que ele não se estabiliza a tempo de ajudar. Qual dos três desfechos acontece depende do que você configurou antes do deploy:

PolíticaO que acontece no limiteRaio de impacto
A. Sem limiteo servidor fica sem memória e é encerrado; ao reiniciar, ele reproduz o seu log de escrita antecipada (minutos, nos quais não ingere nada) e depois volta a crescertodas as métricas de todas as equipes: painéis em branco e alertas que não disparam, justamente quando um incidente é provável
B. Um limite por métrica (ou por tenant)as amostras de séries novas dessa métrica são rejeitadas, com um contador sobre o qual você pode alertar; as séries existentes e todas as outras métricas continuam funcionandouma métrica perde os clientes que apareceram primeiro depois do limite
C. Descartar ou limitar o rótulo na ingestão (uma regra de relabelling, ou uma revisão de código que rejeita rótulos sem limite)o número de séries continua em 150.000nenhum; as perguntas por cliente vão para logs e traces, que foram feitos para elas

As lições operacionais: alerte sobre a taxa de crescimento das séries ativas (e não só sobre a memória), ponha um limite em cada tenant e métrica, verifique os valores dos rótulos na revisão ("isto pode ter mais do que algumas centenas de valores?"), mantenha o deploy anterior fácil de reverter e lembre que remover o rótulo não libera a memória de imediato, pois as séries antigas ficam na memória até a retenção ou o head block expirar. O valor de memória (3 KiB) é a hipótese de trabalho do guia: meça o seu próprio sistema, porque ele varia várias vezes conforme os rótulos, o motor e a sua versão. Não executei o Prometheus nem outro servidor real para este guia; o que se mostra é aritmética e uma simulação com semente fixa do número de séries distintas.

6. Resuma os dados antigos: rollups

Ninguém precisa de resolução de dez segundos de um ano atrás. O downsampling troca amostras brutas antigas por agregados sobre janelas maiores. Para uma série amostrada a cada 10 segundos, um ano de dados brutos são 3 153 600 pontos; os rollups de 1 minuto guardam 525 600 (6 vezes menos) e os rollups de uma hora, 8 760 (360 vezes menos). Uma política típica é dados brutos por 2 semanas, rollups de 1 minuto por 3 meses, rollups de uma hora por 2 anos, cada camada descartada por partição.

O que você guarda em um rollup importa, porque não se recupera o que não foi armazenado. Guarde contagem, soma, mínimo e máximo, para que a média possa ser recalculada (soma / contagem, ponderada corretamente entre janelas) e os extremos não fiquem escondidos. Para a latência há um problema, mostrado a seguir.

Percentis não podem ser tirados em média

Suponha que a instância A atendeu 9 000 requisições, todas em 50 ms, e a instância B atendeu 1 000 requisições, das quais 20% levaram 900 ms. Seus percentis 99 são 50 ms e 900 ms. A média desses dois é 475 ms, que não é uma latência real de modo algum. O percentil 99 verdadeiro de todas as 10 000 requisições é 900 ms (2% das requisições foram lentas), e a média de todas as requisições é 67 ms, o que as esconde. Os percentis, ao contrário de somas e contagens, não se combinam. A solução são os histogramas: guarde, para cada série, quantas requisições caíram em cada balde de latência (as contagens podem ser somadas entre instâncias e ao longo do tempo) e calcule os percentis a partir do histograma mesclado na hora da consulta. Os baldes devem ser escolhidos perto dos valores que importam (seu objetivo de latência), porque a resposta só é tão exata quanto a largura do balde. Sketches como o t-digest e o DDSketch dão um resultado mais preciso em menos espaço.

7. O próprio tempo é incômodo

7.1 Dados atrasados, correções e backfills em detalhe

"Decida quão tarde uma amostra pode chegar" esconde várias decisões separadas. Simulei seis horas de uma série (uma amostra por minuto) cujas amostras chegam com uma dispersão realista: 90% em até 10 segundos, 8% em até 5 minutos e 2% de dispositivos que se reconectam até duas horas depois. Os rollups são somas de 5 minutos. A simulação é determinística (late.py) e usa apenas a biblioteca padrão do Python; as proporções são uma suposição minha, não a medição de nenhum sistema.

1. Um rollup selado em um horário perde as amostras atrasadas. A política "selar uma janela no seu fim mais uma latência permitida L e descartar o que chegar depois":

Latência permitida LAmostras descartadas (de 360)Soma que falta nos rollupsUm rollup é final depois de
0 (selar de imediato)174,96%0 s
1 minuto144,07%60 s
10 minutos51,54%10 min
2 horas00,00%2 horas

Cada linha é uma troca: um L pequeno dá painéis pontuais e totais silenciosamente errados, e um L grande é exato, mas significa que as duas últimas horas são "provisórias". A alternativa é uma política de recálculo (a última linha da saída): uma amostra atrasada reagrega a janela a que pertence, nada se perde, e o custo é que os rollups publicados mudam (17 reescritas aqui) e todo consumidor precisa tolerar números que se movem. Defina a política por métrica. Contadores usados para cobrança precisam da resposta exata, e um gráfico de CPU da última hora não. Guarde sempre o horário do evento e o horário de ingestão, para poder dizer depois o que se sabia quando. E conte os descartes: uma métrica como late_samples_dropped_total transforma uma perda silenciosa em algo sobre o qual se pode alertar.

2. Correções de amostras históricas exigem os dados brutos. Um sensor defeituoso informou 90 onde o valor verdadeiro era 14. Se as amostras brutas ainda existem, você corrige a amostra e recalcula o rollup. Se a retenção já as apagou (dados brutos por 2 dias e rollups por 90 é uma política comum), você só pode ajustar o rollup pela diferença. A simulação mostra o que sobrevive:

Campo do rollupDepois de corrigir 90 para 14 só com o rollupValor verdadeiro
contagem66
soma72,0 (ajustável pelo delta)72,0
média12,0 (derivada da soma e da contagem)12,0
máximo90,0 (errado)14

Somas, contagens e médias podem ser reparadas por um delta, mas um mínimo ou máximo não pode, porque você já não sabe qual era a segunda maior amostra; histogramas também não podem ser reparados sem os valores originais. Assim, uma janela de correção é outra regra de retenção: decida por quanto tempo depois do fato uma correção é aceita, guarde os dados brutos pelo menos por esse tempo e registre cada correção como um evento próprio (valor antigo, valor novo, quem, por quê), em vez de sobrescrever o histórico em silêncio. Para dados regulados, veja a seção sobre trilha de auditoria no guia de event sourcing.

3. Um backfill precisa ser idempotente. Carregar histórico (uma migração, a reprodução de uma queda, o backlog de um dispositivo novo) às vezes será executado duas vezes, depois de um timeout ou de uma falha parcial. Escrever um rollup aditivo (sum = sum + x) duas vezes o dobrou (200 onde 100 é o certo), enquanto uma escrita com chave (série, janela) que substitui o valor (INSERT ... ON CONFLICT DO UPDATE) ficou em 100. Use série e janela como chave dos backfills, faça cada execução substituir em vez de somar e carregue do mais antigo para o mais novo ou por janelas inteiras, para que uma execução pela metade possa ser repetida.

4. Backfill e retenção brigam entre si. Se a retenção guarda 30 dias e você carrega 45 dias de histórico, 15.000 das 45.000 linhas (um terço, no exemplo) são removidas pela próxima execução da retenção, seja qual for a sua intenção; com partições por dia, as partições antigas são criadas e removidas de novo, ou o insert falha porque não existe partição. Decida primeiro se o histórico mais antigo que o período de retenção é desejado: se for, carregue-o direto nas camadas de rollup que são mantidas (não na tabela bruta); se não for, rejeite-o na entrada, com um erro claro. Um backfill que escreve muitos dados brutos também compete com a ingestão ao vivo pelos mesmos discos e pelo mesmo log de escrita antecipada (veja a seção 2); portanto, execute-o em segundo plano com limite de taxa e, se puder evitar, não na mesma partição das escritas ao vivo.

5. Rollups e retenção precisam ser sequenciados. Remover uma partição bruta antes de o seu rollup ser final perde dados para sempre, e o limite de latência do ponto 1 é um limite inferior para quanto tempo os dados brutos devem ser mantidos. A ordem é: os dados brutos chegam, a janela é selada (ou recalculada até a janela de correção fechar), o rollup é escrito e verificado, e só então a partição bruta é removida. Faça o job de remoção se recusar a rodar se o rollup daquele intervalo não existir, e mantenha uma partição extra de margem.

8. Push ou pull, e a escolha do banco de dados

As métricas chegam ao armazenamento de duas maneiras. No modelo pull (Prometheus), o servidor de monitoramento coleta o endpoint /metrics de cada alvo em um agendamento: ele sabe quais alvos existem, um alvo fora do ar é, ele próprio, um sinal, e os alvos não conseguem inundá-lo. No modelo push (StatsD, exportadores do OpenTelemetry, agentes), os clientes enviam dados, o que serve para jobs de vida curta e dispositivos atrás de firewalls, mas exige um buffer e controle de fluxo.

EscolhaEncaixa em
Prometheus (ou um armazenamento de longo prazo compatível, como Thanos, Mimir ou VictoriaMetrics)métricas de infraestrutura e de aplicação, com o ecossistema de alertas
PostgreSQL com particionamento por tempo, ou TimescaleDBvolume moderado, quando você quer SQL e junções com seus outros dados; o experimento acima mostra o que acertar
ClickHouse e outros armazenamentos colunaresvolume muito alto, consultas analíticas sobre eventos e logs
InfluxDB e semelhantesbancos de dados de séries temporais feitos para o propósito, com políticas de retenção e rollup
Um serviço gerenciado na nuvemquando você prefere não operá-lo
Um log ou stream (Kafka) na frentepara fazer buffer, reprocessar e alimentar vários consumidores; é o buffer do diagrama

Para muitos sistemas, o começo certo é o mais simples: escritas em lotes em um Postgres particionado por tempo. Passe a um armazenamento especializado quando a contagem de séries, a taxa de ingestão ou a retenção superarem uma máquina, e não o escale de um jeito que ignore as razões deste guia (fazer o sharding de uma tabela de séries temporais por tempo põe todas as novas escritas em um shard; faça o shard por série, ou por série e tempo).

9. Erros comuns

10. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Três arquivos. ingest.sh e retention.sql precisam de um servidor PostgreSQL 16 descartável (use um banco de dados temporário, nunca um de produção): o primeiro grava as mesmas 50 000 amostras por quatro métodos, o segundo constrói uma tabela de 5 000 000 de linhas com e sem partições diárias e remove os dois dias mais antigos das duas maneiras. gorilla.py usa apenas a biblioteca padrão do Python; ele conta os bits de que as codificações do artigo do Gorilla precisariam em séries sintéticas (minha reconstrução dos layouts de bits publicados, não o código de nenhum banco de dados real) e faz a aritmética de cardinalidade, rollups e percentis. Os tempos do Postgres são execuções únicas em uma pequena máquina virtual de dois núcleos com as configurações padrão (fsync ligado, 128 MB de shared buffers) e variam entre execuções; o que importa são as razões entre os métodos. O valor de memória por série (3 KB) é uma suposição para fins da aritmética; sistemas reais diferem por um fator de poucas vezes.

ingest.sh: quatro maneiras de gravar 50 000 linhas no Postgres

#!/bin/bash
# Postgres ingest: the same 50,000 metric samples written four ways. Needs a scratch Postgres and python3.
# PSQL="psql -h <socket dir> -p <port> -d <database> -X -q"
PSQL=${PSQL:-psql}
N=50000
python3 - <<PY
import random
r = random.Random(7)
rows = [(f"2026-10-01 00:{(i//600)%60:02d}:{(i//10)%60:02d}.{(i%10)*100:03d}+00", i % 50, round(40 + r.random()*20, 2)) for i in range($N)]
open("one.sql", "w").write("".join(f"INSERT INTO samples VALUES ('{t}', {s}, {v});\n" for t, s, v in rows))
open("one_tx.sql", "w").write("BEGIN;\n" + "".join(f"INSERT INTO samples VALUES ('{t}', {s}, {v});\n" for t, s, v in rows) + "COMMIT;\n")
open("multi.sql", "w").write("".join("INSERT INTO samples VALUES " + ",".join(f"('{t}', {s}, {v})" for t, s, v in rows[k:k+1000]) + ";\n" for k in range(0, $N, 1000)))
open("copy.csv", "w").write("".join(f"{t},{s},{v}\n" for t, s, v in rows))
PY
reset() { $PSQL -c "DROP TABLE IF EXISTS samples; CREATE TABLE samples (ts timestamptz NOT NULL, series int NOT NULL, value double precision NOT NULL);"; }
timeit() { # label command...
  label=$1; shift; reset; s=$(date +%s.%N); "$@" >/dev/null; e=$(date +%s.%N)
  awk -v l="$label" -v s=$s -v e=$e -v n=$N 'BEGIN{printf "%-44s %7.2f s  %9.0f rows/s\n", l, e-s, n/(e-s)}'
}
timeit "one INSERT per transaction (autocommit)" $PSQL -f one.sql
timeit "one transaction, one INSERT per row"       $PSQL -f one_tx.sql
timeit "1,000 rows per INSERT statement"           $PSQL -f multi.sql
timeit "COPY"                                      $PSQL -c "\\copy samples FROM 'copy.csv' CSV"

retention.sql: DELETE contra descartar uma partição

-- Retention: delete old data with DELETE, or by dropping a partition. 5,000,000 samples over 10 days.
\timing on
DROP TABLE IF EXISTS plain, part CASCADE;
CREATE TABLE plain (ts timestamptz NOT NULL, series int NOT NULL, value double precision NOT NULL);
CREATE TABLE part  (ts timestamptz NOT NULL, series int NOT NULL, value double precision NOT NULL) PARTITION BY RANGE (ts);
SELECT format('CREATE TABLE part_d%s PARTITION OF part FOR VALUES FROM (%L) TO (%L)', d, ('2026-10-01'::date + d), ('2026-10-01'::date + d + 1)) FROM generate_series(0, 9) d \gexec
INSERT INTO plain SELECT '2026-10-01'::timestamptz + (i * interval '0.1728 seconds'), i % 100, random() FROM generate_series(0, 4999999) i;
INSERT INTO part SELECT * FROM plain;
CREATE INDEX ON plain (ts); CREATE INDEX ON part (ts);
VACUUM ANALYZE plain; VACUUM ANALYZE part;
\timing off
SELECT 'rows', count(*), pg_size_pretty(pg_total_relation_size('plain')) AS plain_size, pg_size_pretty((SELECT sum(pg_total_relation_size(inhrelid)) FROM pg_inherits WHERE inhparent = 'part'::regclass)::bigint) AS partitioned_size FROM plain;
SELECT pg_current_wal_lsn() AS lsn0 \gset
\echo --- remove the oldest 2 days (1,000,000 rows) with DELETE
\timing on
DELETE FROM plain WHERE ts < '2026-10-03';
\timing off
SELECT pg_size_pretty(pg_current_wal_lsn() - :'lsn0'::pg_lsn) AS wal_written_by_delete;
SELECT pg_current_wal_lsn() AS lsn0 \gset
SELECT 'plain after DELETE, before VACUUM', pg_size_pretty(pg_total_relation_size('plain')), (SELECT count(*) FROM plain) AS rows_left;
\echo --- the same with DROP of two partitions
\timing on
DROP TABLE part_d0; DROP TABLE part_d1;
\timing off
SELECT pg_size_pretty(pg_current_wal_lsn() - :'lsn0'::pg_lsn) AS wal_written_by_drop;
SELECT 'partitioned after DROP', pg_size_pretty((SELECT sum(pg_total_relation_size(inhrelid)) FROM pg_inherits WHERE inhparent = 'part'::regclass)::bigint), (SELECT count(*) FROM part) AS rows_left;
\echo --- VACUUM FULL is needed to give the deleted space back to the operating system
\timing on
VACUUM FULL plain;
\timing off
SELECT 'plain after VACUUM FULL', pg_size_pretty(pg_total_relation_size('plain'));
\echo --- a query for the last hour: partition pruning
EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF, SUMMARY ON) SELECT count(*) FROM part WHERE ts >= '2026-10-10 22:00' AND ts < '2026-10-10 23:00';

gorilla.py: compressão, cardinalidade, rollups e percentis

"""Gorilla-style compression of a time series: delta-of-delta timestamps and XOR-ed floats.
Counts the bits each encoding needs (the bit counts follow the Gorilla paper, VLDB 2015)."""
import math, random, struct

def bits_ts(ts):
    """Timestamps: the first is stored whole (64 bits); then the delta of the deltas is stored in 1 to 36 bits."""
    total, prev_delta = 64 + 14, None
    for a, b in zip(ts, ts[1:]):
        delta = b - a
        if prev_delta is None: total += 14; prev_delta = delta; continue  # first delta: 14 bits
        dod = delta - prev_delta; prev_delta = delta
        if dod == 0: total += 1
        elif -63 <= dod <= 64: total += 2 + 7
        elif -255 <= dod <= 256: total += 3 + 9
        elif -2047 <= dod <= 2048: total += 4 + 12
        else: total += 4 + 32
    return total

def f2i(x): return struct.unpack(">Q", struct.pack(">d", x))[0]

def bits_values(vs):
    """Values: XOR with the previous value. Identical -> 1 bit; else a control bit plus the meaningful middle bits."""
    total, prev, lead, trail = 64, f2i(vs[0]), None, None
    for v in vs[1:]:
        x = f2i(v) ^ prev; prev = f2i(v)
        if x == 0: total += 1; continue
        l = min(64 - x.bit_length(), 31); t = (x & -x).bit_length() - 1
        if lead is not None and l >= lead and t >= trail: total += 2 + (64 - lead - trail)       # reuse the previous window
        else: total += 2 + 5 + 6 + (64 - l - t); lead, trail = l, t                                 # new window: header + bits
    return total

def report(name, ts, vs):
    n = len(ts); raw = n * 16 * 8
    bt, bv = bits_ts(ts), bits_values(vs)
    print(f"{name:<38} timestamps {bt/n:5.1f} bits  values {bv/n:5.1f} bits  total {(bt+bv)/n:5.1f} bits per sample  ({raw/(bt+bv):4.1f}x smaller than 16 bytes)")

r = random.Random(3); n = 100_000
regular = [1_700_000_000 + 10 * i for i in range(n)]                       # a scrape every 10 s, on time
jitter  = [1_700_000_000 + 10 * i + r.choice((-1, 0, 0, 0, 1)) for i in range(n)]  # +/- 1 s of jitter
print("--- timestamps and values together, 100,000 samples")
report("counter: +1 each step", regular, [float(i) for i in range(n)])
report("gauge that mostly does not change", regular, [round(50 + (i // 500) % 3, 0) for i in range(n)])
report("gauge: smooth sensor (1 decimal)", regular, [round(20 + 3 * math.sin(i / 2000) + r.gauss(0, .05), 1) for i in range(n)])
report("gauge: full-precision noise", regular, [20 + r.gauss(0, 1) for _ in range(n)])
report("counter with jittery timestamps", jitter, [float(i) for i in range(n)])

print("--- how many series? (cardinality is the product of the label values)")
for name, dims in (("service x status code", (20, 5)), ("... x endpoint", (20, 5, 50)), ("... x instance", (20, 5, 50, 30)), ("... x user id (10,000 users)", (20, 5, 50, 30, 10_000))):
    s = math.prod(dims); print(f"{name:<32} {s:>14,} series  ~{s * 3 / 1024:>12,.0f} MB of index and head memory at 3 KB per series")

print("--- rollups: points kept for one series sampled every 10 s for a year")
samples = 365 * 24 * 360
for name, factor in (("raw samples, 10 s", 1), ("1-minute rollups", 6), ("1-hour rollups", 360)):
    print(f"{name:<20} {samples // factor:>10,} points ({factor}x fewer)")

print("--- percentiles cannot be averaged")
def pct(xs, p): xs = sorted(xs); return xs[min(len(xs) - 1, math.ceil(p / 100 * len(xs)) - 1)]
a = [50] * 9000                       # instance A: 9,000 requests, all fast (50 ms)
b = [50] * 800 + [900] * 200          # instance B: 1,000 requests, 20% slow (900 ms)
print(f"p99 of A: {pct(a, 99)} ms   p99 of B: {pct(b, 99)} ms   average of the two p99s: {(pct(a, 99) + pct(b, 99)) / 2:.0f} ms")
print(f"p99 of all 10,000 requests together: {pct(a + b, 99)} ms   (average of the two p99s is wrong whenever the instances differ)")
print(f"mean latency of all requests: {sum(a + b) / len(a + b):.0f} ms   (the mean hides the slow 2%)")

Dados atrasados, correções e backfills: late.py

Apenas a biblioteca padrão do Python; determinístico.

"""Late data, corrections, backfills and retention against 5-minute rollups. stdlib only, deterministic."""
import random, sqlite3, math
random.seed(7)
W = 300                      # rollup window: 5 minutes
HOURS = 6
N = HOURS * 60               # one sample per minute, value = 10 + (t % 7)

def delay():                 # seconds between event time and arrival
    r = random.random()
    if r < 0.90: return random.uniform(0, 10)
    if r < 0.98: return random.uniform(10, 300)
    return random.uniform(300, 7200)        # a device that reconnects later

events = []                  # (event_time, arrival_time, value)
for m in range(N):
    t = m * 60
    events.append((t, t + delay(), 10 + (m % 7)))
events.sort(key=lambda e: e[1])
true_sum = {}
for t, _, v in events: true_sum[t // W] = true_sum.get(t // W, 0) + v
true_total = sum(true_sum.values())

def run(policy, L):
    """policy 'finalize': a window is sealed at window_end + L; later samples are dropped.
       policy 'recompute': a window is re-aggregated whenever a late sample lands in it."""
    sums, count, dropped, rewrites, sealed = {}, {}, 0, 0, set()
    ready_at = {}
    for t, a, v in events:
        w = t // W
        seal_time = (w + 1) * W + L
        if policy == 'finalize':
            if a > seal_time: dropped += 1; continue
            sums[w] = sums.get(w, 0) + v; count[w] = count.get(w, 0) + 1
            ready_at[w] = seal_time
        else:
            if w in sums: rewrites += 1 if a > (w + 1) * W else 0
            sums[w] = sums.get(w, 0) + v; count[w] = count.get(w, 0) + 1
    tot = sum(sums.values())
    miss = 100 * (true_total - tot) / true_total
    lag = (max(0, L) if policy == 'finalize' else 0)
    return dropped, miss, rewrites, lag

print("samples:", N, "late(>5 min):", sum(1 for e in events if e[1] - e[0] > 300))
print("policy,L_seconds,dropped,missing_sum_pct,rewrites_of_published_windows,min_delay_before_rollup_is_final_s")
for L in (0, 60, 600, 7200):
    d, m, r, lag = run('finalize', L); print(f"finalize,{L},{d},{m:.2f},{r},{lag}")
d, m, r, lag = run('recompute', 0); print(f"recompute,-,{d},{m:.2f},{r},0 (never final)")

# --- corrections: raw is kept 2 days, rollups 90. Correct one sample after the raw data is gone.
con = sqlite3.connect(":memory:")
con.execute("create table roll(w int primary key, n int, s real, mn real, mx real)")
vals = [10, 12, 11, 13, 90, 12]            # 90 is a faulty reading
con.execute("insert into roll values(0,?,?,?,?)", (len(vals), sum(vals), min(vals), max(vals)))
# correction arrives: the 90 should have been 14. Raw samples were deleted by retention.
old, new = 90, 14
con.execute("update roll set s=s-?+? where w=0", (old, new))   # sum and count can be adjusted by the delta
print("\nafter a delta correction without raw data:", con.execute("select n,s,mn,mx, s/n from roll").fetchone(), "(true max is 14, mean 12.0)")

# --- backfill: re-running a load without an idempotent key
con.execute("create table naive(w int, s real)")
con.execute("create table keyed(w int primary key, s real)")
for _ in range(2):                         # the job is run twice, e.g. after a timeout
    con.execute("insert into naive values(0, 100)")
    con.execute("insert into keyed values(0,100) on conflict(w) do update set s=excluded.s")
print("backfill run twice: add-only rollup =", con.execute("select sum(s) from naive").fetchone()[0],
      "; upsert by window =", con.execute("select s from keyed").fetchone()[0], "(true 100)")

# --- backfill against retention: 45 days of history loaded into a store with 30-day retention
days_back, keep = 45, 30
rows_per_day = 1000
kept = rows_per_day * keep
print(f"\nbackfill of {days_back} days with {keep}-day retention: {rows_per_day*days_back} rows written, "
      f"{rows_per_day*(days_back-keep)} ({100*(days_back-keep)/days_back:.0f}%) removed by the next retention run")

Um incidente de cardinalidade: cardinality.py

Apenas a biblioteca padrão do Python; leva cerca de seis segundos.

"""A deploy adds a customer_id label. Model of what happens to a server with a series limit.
Assumptions are stated in the output; this is arithmetic and a seeded simulation, not a measurement of Prometheus."""
import random
random.seed(3)
BYTES_PER_SERIES = 3 * 1024            # the guide's working figure
RAM_FOR_SERIES = 8 * 1024**3           # 8 GiB reserved for series on the server
LIMIT = RAM_FOR_SERIES // BYTES_PER_SERIES
BASE = 150_000                         # existing series (20 services x 5 statuses x 50 endpoints x 30 instances)
CUSTOMERS = 400_000                    # distinct customers seen over a day
STATUS, ENDPOINTS_PER_METRIC, INSTANCES = 5, 50, 30
REQ_PER_MIN = 60_000
# each request picks a customer from a Zipf-like popularity; the new series key is (customer, status, endpoint) per instance
def zipf_pick():
    return int(CUSTOMERS ** random.random())          # heavy tail: a few busy customers, a long tail

seen = set(); series = BASE; t_hit = None; per_min = []
for minute in range(1, 61):
    for _ in range(REQ_PER_MIN):
        key = (zipf_pick(), random.randrange(STATUS), random.randrange(ENDPOINTS_PER_METRIC), random.randrange(INSTANCES))
        if key not in seen: seen.add(key)
    new = len(seen)
    series = BASE + new
    per_min.append(series)
    if t_hit is None and series * BYTES_PER_SERIES >= RAM_FOR_SERIES: t_hit = minute
print(f"series limit for {RAM_FOR_SERIES//1024**3} GiB at {BYTES_PER_SERIES//1024} KiB/series: {LIMIT:,}")
for m in (1, 5, 10, 20, 40, 60):
    s = per_min[m-1]; print(f"minute {m:>2}: {s:>10,} series, {s*BYTES_PER_SERIES/1024**3:5.1f} GiB, {100*s/LIMIT:5.0f}% of the limit")
print("limit first reached at minute:", t_hit)

# What each policy does once the limit is reached (counts of samples/s affected, simple accounting)
total_samples_per_s = BASE / 10                       # one sample per series every 10 s
print(f"\nhealthy ingest: {total_samples_per_s:,.0f} samples/s across {BASE:,} series")
print("A  no limit:           process is OOM-killed -> ALL series stop; restart replays the write-ahead log (minutes); dashboards and alerts are blind")
print("B  per-metric limit:   new series of http_requests rejected; the", f"{BASE-1:,}", "other series keep working; an alert fires on 'series rejected'")
print("C  drop label at ingest (relabel customer_id away): series count stays", f"{BASE:,}", "; the per-customer question moves to logs/traces")

Fontes

Pratique este tema: Databases

Mais guias