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ípico | Uma carga de séries temporais | |
|---|---|---|
| Escritas | aleatórias: atualize este usuário, insira aquele pedido | acrescentar no instante atual, de milhares a milhões por segundo |
| Atualizações e exclusões de linhas antigas | comuns | quase nunca; os dados antigos são descartados em bloco por idade |
| Leituras | por chave, pequenas | por intervalo de tempo e agregação sobre muitas linhas |
| Valor dos dados | permanece | cai com a idade (recentes: precisos; antigos: resumidos) |
| Linha | muitas colunas, variadas | um 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étodo | Tempo | Linhas por segundo | Relativo |
|---|---|---|---|
um INSERT por transação (autocommit) | 16,7 s | 3 000 | 1 |
uma transação com 50 000 INSERTs de uma linha | 3,3 s | 15 000 | 5 vezes |
1 000 linhas por comando INSERT | 0,40 s | 125 000 | 42 vezes |
COPY | 0,12 s | 420 000 | 140 vezes |
Os mesmos dados e o mesmo banco de dados, e um fator de 140. Para onde isso vai?
- Commits. Toda transação precisa ser tornada durável, o que significa forçar o write-ahead log (o WAL, um log sequencial de mudanças; veja motores de armazenamento) para o disco e esperar por isso. Um commit por linha significa um flush de disco por linha. Pôr 50 000 linhas em uma transação faz isso uma vez. (O Postgres também pode agrupar os commits de clientes concorrentes em um flush, e
synchronous_commit = offtroca uma pequena janela de possível perda por velocidade; nenhum dos dois substitui o batching.) - Idas e voltas e parsing. Cada comando custa uma ida e volta de rede, parsing e planejamento. Um comando com 1 000 linhas faz isso uma vez para 1 000 linhas.
- O
COPYpula a maior parte da maquinaria por comando e transmite as linhas em bloco, e é por isso que é a forma padrão de carregar dados.
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:
- Delta-of-delta para timestamps. Guarde a diferença entre timestamps consecutivos (o delta) e depois a diferença entre deltas consecutivos. Para uma amostra a cada 10 segundos, o delta é sempre 10, então o delta-of-delta é 0, que ocupa um bit.
- XOR para valores. A representação de ponto flutuante IEEE de dois valores próximos compartilha seus bits iniciais (sinal, expoente e o topo da mantissa). Faça o XOR do novo valor com o anterior: se forem idênticos, o resultado é só zeros (um bit); do contrário, só os bits "significativos" do meio precisam ser guardados.
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érie | Bits por amostra | Compressão |
|---|---|---|
| um gauge que quase não muda | 2,0 | 64 vezes |
| um contador que aumenta de um em um | 16,4 | 7,8 vezes |
| um sensor, suave, uma casa decimal | 28,6 | 4,5 vezes |
| o mesmo com timestamps oscilando um segundo | 22,2 | 5,8 vezes |
| ruído aleatório com precisão total de ponto flutuante | 54,8 | 2,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 simples | DROP de duas partições diárias | |
|---|---|---|
| tempo | 0,8 a 1,3 s (duas execuções) | 54 ms |
| WAL gravado | 103 MB | 2,4 MB |
| tamanho da tabela depois | 356 MB (inalterado) | 285 MB (espaço liberado na hora) |
| trabalho extra depois | VACUUM FULL: 3,6 s e um lock exclusivo, para chegar a 285 MB | nenhum |
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:
| Labels | Séries | Memória com 3 KB supostos por série |
|---|---|---|
| serviço (20) × código de status (5) | 100 | desprezível |
| × endpoint (50) | 5 000 | 15 MB |
| × instância (30) | 150 000 | 440 MB |
| × id de usuário (10 000 usuários) | 1 500 000 000 | cerca 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 deploy | Séries | Memória | Parcela do limite |
|---|---|---|---|
| 1 | 208.727 | 0,6 GiB | 7% |
| 10 | 677.471 | 1,9 GiB | 24% |
| 20 | 1.147.770 | 3,3 GiB | 41% |
| 40 | 2.023.523 | 5,8 GiB | 72% |
| 60 | 2.851.356 | 8,2 GiB | 102% |
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ítica | O que acontece no limite | Raio de impacto |
|---|---|---|
| A. Sem limite | o 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 crescer | todas 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 funcionando | uma 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.000 | nenhum; 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
- Dados tardios e fora de ordem: um dispositivo móvel envia as leituras de ontem quando se reconecta; uma fila reproduz uma hora de dados depois de uma queda. Decida o quanto uma amostra pode chegar tarde e ainda ser aceita, e mantenha o caminho de escrita capaz de inserir em partições mais antigas (mas ainda abertas). Os rollups de uma janela precisam ser recalculados ou finalizados só depois de passar o limite de atraso. Distinga o tempo do evento (quando aconteceu) do tempo de ingestão (quando você recebeu).
- Os relógios diferem entre máquinas (sistemas distribuídos); guarde timestamps em UTC, com resolução suficiente, e use o tempo do servidor quando não se pode confiar nos relógios dos dispositivos.
- Duplicatas de retries: torne a chave
(série, timestamp)única ou aceite uma sobrescrita. - As lacunas são informação: uma amostra ausente (o agente morreu) é diferente de um zero. Alerte sobre dados ausentes separadamente do alerta sobre valores.
- Fusos horários e janelas de calendário ("por dia" para um usuário) são uma questão de apresentação; agregue em UTC no banco de dados e converta na borda.
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 L | Amostras descartadas (de 360) | Soma que falta nos rollups | Um rollup é final depois de |
|---|---|---|---|
| 0 (selar de imediato) | 17 | 4,96% | 0 s |
| 1 minuto | 14 | 4,07% | 60 s |
| 10 minutos | 5 | 1,54% | 10 min |
| 2 horas | 0 | 0,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 rollup | Depois de corrigir 90 para 14 só com o rollup | Valor verdadeiro |
|---|---|---|
| contagem | 6 | 6 |
| soma | 72,0 (ajustável pelo delta) | 72,0 |
| média | 12,0 (derivada da soma e da contagem) | 12,0 |
| máximo | 90,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.
| Escolha | Encaixa 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 TimescaleDB | volume moderado, quando você quer SQL e junções com seus outros dados; o experimento acima mostra o que acertar |
| ClickHouse e outros armazenamentos colunares | volume muito alto, consultas analíticas sobre eventos e logs |
| InfluxDB e semelhantes | bancos de dados de séries temporais feitos para o propósito, com políticas de retenção e rollup |
| Um serviço gerenciado na nuvem | quando você prefere não operá-lo |
| Um log ou stream (Kafka) na frente | para 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
- Uma linha, um commit; ou uma chamada de rede por amostra.
DELETEpara expiração em uma tabela grande e depois se perguntar por que o disco está cheio e as réplicas atrasam.- Valores de labels ilimitados (ids de usuário, URLs com ids) e nenhum alerta sobre o número de séries.
- Tirar a média de percentis, ou monitorar apenas a média.
- Dados brutos com resolução total para sempre, ou rollups que descartam o máximo.
- Não criar as próximas partições com antecedência.
- Vários índices em uma tabela que recebe milhões de linhas por hora.
- Nenhum plano para dados tardios, duplicatas e amostras ausentes.
- Tratar amostras perdidas como zeros.
- Pôr a carga de séries temporais na mesma instância de banco de dados da aplicação transacional, de modo que uma enxurrada de métricas deixa o checkout lento.
10. Coisas a mencionar em uma entrevista
- A carga: majoritariamente de acréscimo, expiração em bloco por idade, leituras por intervalo e agregações.
- Batching e group commit; por que
COPYe inserts de várias linhas são de 40 a 140 vezes mais rápidos que commit por linha (medi 3 000 contra 420 000 linhas por segundo). - Filas para buffer e backpressure; escritas idempotentes para retries.
- Compressão delta-of-delta e XOR, e por que a regularidade comprime (de 2 a 64 vezes no modelo).
- Particionamento por tempo: descartar uma partição contra o
DELETE(milissegundos contra um segundo mais vacuum), partition pruning, criar partições com antecedência. - A cardinalidade como produto dos valores dos labels; labels limitados; onde os dados de alta cardinalidade pertencem.
- Camadas de downsampling e o que guardar (contagem, soma, mínimo, máximo); histogramas porque percentis não se tiram em média.
- Dados tardios, tempo do evento contra tempo de ingestão, push contra pull.
Resumo rápido
- Uma carga de séries temporais é majoritariamente de acréscimo e lida de forma agregada por tempo, então agrupe as escritas em lotes (as mesmas 50 000 linhas levaram 16,7 s com um commit por vez e 0,12 s com
COPY). - Comprima a regularidade: timestamps delta-of-delta e valores XOR custam de 2 a 55 bits por amostra no modelo, contra 128 brutos.
- Expire descartando partições de tempo (54 ms, 2,4 MB de WAL, espaço devolvido) em vez de
DELETE(cerca de um segundo, 103 MB de WAL, nenhum espaço devolvido até uma reescrita). - Fique de olho na cardinalidade: a contagem de séries é o produto dos valores dos labels, e um único label de id de usuário pode transformar milhares de séries em bilhões.
- Faça downsampling dos dados antigos guardando contagem, soma, mínimo e máximo, use histogramas para a latência porque percentis não podem ser tirados em média e planeje para dados tardios, duplicados e ausentes.
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
- Tuomas Pelkonen et al., Gorilla: A Fast, Scalable, In-Memory Time Series Database, Proceedings of the VLDB Endowment 8(12), 2015 (timestamps delta-of-delta e valores comprimidos por XOR).
- Fabian Reinartz, Writing a Time Series Database from Scratch (2017), e a documentação do Prometheus: armazenamento, modelo de dados, histogramas e summaries e práticas de instrumentação (cardinalidade de labels).
- Documentação do PostgreSQL: Populating a database (COPY, batching), COPY, Table partitioning, Routine vacuuming e Asynchronous commit.
- Timescale, documentação do TimescaleDB (hypertables, compressão, continuous aggregates); ClickHouse, documentação das tabelas MergeTree; InfluxData, documentação do InfluxDB.
- Martin Kleppmann, Designing Data-Intensive Applications (O'Reilly, 2017), capítulo 3 (armazenamento estruturado em log, armazenamento em colunas) e capítulo 11 (processamento de fluxos, lidando com o tempo).
- Gil Tene, How NOT to Measure Latency (palestra), sobre percentis e coordinated omission; o modelo de dados de métricas do OpenTelemetry.
- Betsy Beyer et al., Site Reliability Engineering (O'Reilly, 2016), capítulo 6 "Monitoring Distributed Systems".
Pratique este tema: Databases