时序库选型:高写吞吐、时间聚合与监控指标栈

时序库选型:高写吞吐、时间聚合与监控指标栈

Hello,我是小兔大白糖。 读完能说明 TSDB 用什么换通用事务能力,以及它在监控/指标场景的边界。

估计阅读时间:37 分钟

时序写入优化与窗口聚合
时序写入优化与窗口聚合 · 点击查看 SVG 原图

TL;DR

时序数据库(Time-Series Database, TSDB)是为时间戳数据优化的专用存储系统,通过牺牲通用事务能力换取极致的写入吞吐和聚合查询性能,是交易监控、风控指标和系统可观测性的核心基础设施。


1. 概念定义(是什么)

1.1 核心概念解释

Time-Series Data(时序数据):按时间顺序索引的数据点序列,每条记录天然携带一个时间戳(Timestamp)。典型的时序数据包括服务器 CPU 利用率、交易每秒请求量(QPS)、账户登录频率、风控规则命中次数等。

Tag Set(标签集):描述数据的维度(Dimensions),通常是字符串类型的键值对,用于过滤和分组查询。例如 exchange=大型加密货币交易所, symbol=BTCUSDT, region=ap-southeast-1。Tag 会被索引。

Field Set(字段集):描述数据的实际度量值(Measurements),通常是数值型,如 price=42000.50, volume=1.25, latency_ms=45。Field 默认不被索引(InfluxDB 中)。

Cardinality(基数):由 Tag 组合产生的唯一时间线(Time Series)数量。例如 symbol 有 1000 个值,region 有 5 个值,则基数为 5000。高基数是时序数据库的头号杀手。

Shard(分片):时序数据库按时间范围(如 7 天)对数据进行水平切分的单元。老 Shard 只读,新 Shard 可写,便于生命周期管理和并发查询。

Retention Policy(保留策略):定义数据的存活时间和副本数。过期数据自动删除或降级到冷存储(如 S3)。

Downsampling(降采样):将高频率原始数据聚合为低频率统计值(如 1 秒数据 -> 1 分钟均值/最大/最小值),以减少存储压力和加速历史查询。

Compaction(压缩/合并):后台将多个小数据文件合并为更大、更紧凑的文件,并清理已标记删除的数据。这是 LSM-Tree 家族的核心机制。

1.2 类比说明

类比:医院的体温记录表

想象一个 ICU 病房,护士每小时给每位病人记录一次体温、血压和心率。

  • Timestamp:记录时间(2024-01-15 08:00)。
  • Tag:病人 ID、病房号、床位号(用于找到"哪位病人"的数据)。
  • Field:体温 37.2C、血压 120/80(实际的测量值)。
  • Time Series:"病房A-床位1-体温" 构成一条时间线。
  • Cardinality:如果医院有 1000 位病人,每人 3 个指标,那就是 3000 条时间线。
  • Downsampling:院长不需要看每小时的数据,只需要每天的最高体温和平均体温。
  • Retention:3 年前的体温记录会被销毁或归档到档案室(冷存储)。

这个类比揭示了时序数据的核心特征:写入是追加-only、查询总是带时间范围、维度过滤比点查更频繁、历史数据价值递减。

1.3 为什么需要它(解决了什么问题)

关系型数据库(如 MySQL)在处理时序数据时存在根本性瓶颈:

维度关系型数据库时序数据库
写入模式随机写入,需更新索引顺序追加写入,批量提交
时间范围查询B+ Tree 范围扫描,回表开销大按时间分片,直接顺序读取
聚合查询全表扫描或大范围索引扫描预聚合、向量化执行
数据生命周期手动 DELETE,产生碎片自动 Retention,整 Shard 丢弃
存储成本行存储,压缩率低列存储或专用编码(Gorilla、Delta-of-Delta),压缩率 10:1 以上

在交易系统中,一个撮合引擎每秒可能产生数万到数十万个指标点(每笔订单的延迟、每个风控规则的执行时间、每台机器的 GC 停顿)。MySQL 在这种写入压力下很快会成为瓶颈,而 InfluxDB 或 Prometheus 可以轻松处理每秒百万级的写入。


2. 核心原理与图解

2.1 时序数据模型: everything is a time series

时序数据库的数据模型可以抽象为:

Measurement + Tag Set + Field Set + Timestamp

Example:
  Measurement: order_latency
  Tags:        exchange=大型加密货币交易所, symbol=BTCUSDT, engine=matching-01
  Fields:      p50=12, p99=45, p999=120, count=150000
  Timestamp:   2024-01-15T08:00:00Z

关键设计决策:

  1. Measurement 类比为表名,但无严格 Schema,同一 Measurement 在不同时间点可以有不同的 Field。
  2. Tag 与 Field 分离:Tag 用于 WHERE / GROUP BY,必须索引;Field 用于 SELECT 计算,通常不索引。这种分离避免了索引膨胀。
  3. Timestamp 是主键的第一列:所有数据按时间排序,这是物理存储布局的基石。

2.2 存储引擎原理:TSM vs LSM-Tree vs B+ Tree

B+ Tree 的困境

MySQL InnoDB 使用 B+ Tree 存储数据。对于时序场景:

  • 写入是随机的(如果按时间戳 + Tag 组合做 PK),导致大量页分裂和随机 I/O。
  • 即使主键是 (timestamp, tag),高并发写入也会造成 B+ Tree 的叶子节点竞争(latch contention)。
  • 历史数据删除需要逐行标记或页回收,代价高昂。

LSM-Tree(Log-Structured Merge Tree)

LSM-Tree 将写入转换为顺序追加:

  1. 写入先进入内存中的 MemTable(通常是有序数据结构,如跳表)。
  2. MemTable 写满后,冻结为 Immutable MemTable,并异步刷盘为 SSTable(Sorted String Table)。
  3. 后台 Compaction 过程将多个小 SSTable 合并为大 SSTable,清理过期和重复数据。
  4. 读取时,需要查询 MemTable + 多个 SSTable(读放大)。

LSM-Tree 的优势:

  • 写入吞吐量极高(顺序写)。
  • 数据天然按 key 有序,范围查询友好。
  • 删除只需写一条 Tombstone,由 Compaction 清理。

劣势:

  • 读放大(需查多层)。
  • 写放大(Compaction 反复重写数据)。
  • 空间放大(Compaction 前存在多版本数据)。

InfluxDB TSM(Time-Structured Merge Tree)

InfluxDB 的 TSM 是专为时序数据定制的 LSM-Tree 变体:

  1. WAL(Write-Ahead Log):写入先持久化到 WAL,保证宕机不丢数据。
  2. Cache:内存中的 Hash Map,按 Time Series 组织,存储最近的 Points。
  3. TSM File:只读的数据文件,包含:
    • Index:每个 Time Series 的索引,指向数据块位置。
    • Blocks:按时间顺序压缩存储的 Field 值。使用 Gorilla 或 Delta-of-Delta 压缩。
  4. Compaction:
    • Level 0:将 Cache 快照写入 TSM(类似 LSM 的 L0)。
    • Level 1-3:将多个小的 TSM 合并为更大、压缩率更高的 TSM。高级别的 TSM 覆盖更长的时间范围。

TSM 针对时序数据的优化:

  • 时间列独立压缩:时间戳使用 Delta-of-Delta 编码,压缩率极高(例如从 8 bytes 降到 0.3 bytes / point)。
  • 浮点值 Gorilla 压缩:XOR 相邻值的二进制表示,适合缓慢变化的监控指标。
  • 按 Time Series 分块:每个 Time Series 的数据在文件中连续存放,查询单个时间线只需一次顺序读取。

Prometheus 存储引擎

Prometheus 2.0 后使用自定义的 TSDB(基于 LevelDB 的思想,但完全重写):

  1. Head Block:内存中的活跃数据,最近 2 小时(默认)。使用 mmap 映射内存。
  2. WAL:保证 Head Block 的持久化。
  3. Checkpoint:定期将 WAL 截断,减少重启重放时间。
  4. Persistent Block:每 2 小时将 Head Block 刷盘为只读 Block,并进行 Compaction(合并、索引、压缩)。
  5. Index:每个 Block 包含独立的倒排索引(Posting Lists),支持 Label 快速查找。

Prometheus 的存储不依赖外部 LSM-Tree,而是针对 Pull 模式和短周期数据(15 天默认)做了极致优化。

2.3 架构对比图解

timeseries db basics · 图 2
timeseries db basics · 图 2 · 点击查看 SVG 原图

2.4 降采样(Downsampling)与预聚合

降采样是时序数据库应对"历史数据查询慢"的核心策略。

原理:

  • 原始数据保留短周期(如 7 天,精度 1 秒)。
  • 降采样任务定期将原始数据聚合为粗粒度(如 30 天,精度 1 分钟,只保留 mean/max/min/sum/count)。
  • 查询历史时自动路由到降采样后的数据。

InfluxDB 1.x:Continuous Query(CQ)

CREATE CONTINUOUS QUERY "cq_order_latency" ON "risk_monitor"
BEGIN
  SELECT mean("p99"), max("p99"), min("p99"), count("p99")
  INTO "risk_monitor"."rp_30d"."order_latency_1m"
  FROM "order_latency"
  GROUP BY time(1m), "symbol", "engine"
END

InfluxDB 2.x / Flux:Task

option task = {name: "downsample_order_latency", every: 1m}

from(bucket: "risk_monitor")
  |> range(start: -task.every)
  |> filter(fn: (r) => r._measurement == "order_latency")
  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
  |> to(bucket: "risk_monitor_1m")

Prometheus:Recording Rule

groups:
  - name: risk_metrics.rules
    interval: 30s
    rules:
      - record: risk:order_latency:p99_5m
        expr: histogram_quantile(0.99, sum(rate(order_latency_bucket[5m])) by (le, symbol))
      - record: risk:rule_hit_rate_1m
        expr: sum(rate(rule_hit_total[1m])) by (rule_id, severity) / sum(rate(rule_eval_total[1m])) by (rule_id, severity)

降采样 vs 预聚合的区别:

  • Downsampling:对原始数据做时间维度的粗化,减少数据点数量,但保留维度信息。查询时仍可按原始维度过滤。
  • Pre-aggregation(预聚合):预先计算好常见的聚合结果(如全局 QPS、不分 symbol 的总延迟),查询时直接命中预计算结果,速度最快,但丢失了下钻(drill-down)能力。

2.5 高基数(High Cardinality)问题

高基数是生产环境中时序数据库性能断崖式下降的首要原因。

成因:

  • 将 user_id、order_id、ip_address 等高唯一度字段放入 Tag。
  • 100 万用户每分钟产生一条数据,则基数为 100 万条时间线。
  • InfluxDB 的索引(Series Index)需要为每条时间线维护元数据,内存与查询成本线性增长。

解决策略:

  1. 将高基数字段转为 Field:如果不需要按该维度 GROUP BY 或 WHERE,就放入 Field。
  2. 基数限制与采样:只保留关键维度,或对用户做分桶(如按 user_id 哈希到 100 个桶)。
  3. 使用宽表模型:将相关指标放入同一个 Measurement 的不同 Field,而非不同 Tag。
  4. 分片 Shard 隔离:确保高基数只影响当前活跃 Shard,历史 Shard 只读且可能被压缩。
  5. 选型转向列式存储:InfluxDB IOx(Apache Arrow)或 ClickHouse 对高基数有更好的向量化处理能力。

3. 语法详解与代码示例(怎么用)

3.1 InfluxDB Line Protocol 写入

Line Protocol 是 InfluxDB 的原生写入格式,设计目标是极致的解析速度和紧凑性:

<measurement>[,<tag_key>=<tag_value>...] <field_key>=<field_value>[,...] <timestamp>

交易监控指标写入示例:

order_latency,exchange=大型加密货币交易所,symbol=BTCUSDT,engine=matching-01 p50=12.3,p99=45.6,p999=120.8,count=150000 1705312800000000000
rule_evaluation,exchange=大型加密货币交易所,rule_id=kyc-aml-001,severity=critical hit=1,eval_time_ms=5.2 1705312800000000000
login_frequency,exchange=大型加密货币交易所,region=ap-southeast-1,user_type=vip success=120,failure=3,blocked=1 1705312800000000000

3.2 Java 集成:Spring Boot + Micrometer + Prometheus

Prometheus 是云原生监控的事实标准,通过 Micrometer 可以无缝集成到 Spring Boot 应用。

pom.xml 依赖:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-influx</artifactId>
    </dependency>
</dependencies>

application.yml 配置:

management:
  endpoints:
    web:
      exposure:
        include: prometheus,health,metrics
  metrics:
    tags:
      application: ${spring.application.name}
      exchange: 大型加密货币交易所
    export:
      prometheus:
        enabled: true
      influx:
        enabled: true
        db: risk_monitor
        uri: http://influxdb:8086
        step: 10s
        auto-create-db: true

自定义交易风控指标注册(Service 层):

package com.大型加密货币交易所.risk.metrics;
 
import io.micrometer.core.instrument.*;
import io.micrometer.core.instrument.distribution.DistributionStatisticConfig;
import org.springframework.stereotype.Component;
 
import java.time.Duration;
import java.util.concurrent.TimeUnit;
 
@Component
public class RiskMetricsRegistry {
 
    private final MeterRegistry meterRegistry;
 
    // 交易延迟分布(用于 P99/P999 监控)
    private final Timer orderLatencyTimer;
 
    // 风控规则执行计数器
    private final Counter ruleHitCounter;
    private final Counter ruleEvalCounter;
 
    // 用户行为频率(每用户每分钟登录次数,需配合外部聚合)
    private final Counter loginSuccessCounter;
    private final Counter loginFailureCounter;
 
    // 反欺诈模型打分时延
    private final Timer fraudModelScoreTimer;
 
    // 当前活跃风险事件数(Gauge)
    private final AtomicInteger activeRiskEvents;
 
    public RiskMetricsRegistry(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
 
        // 1. 订单延迟 Timer:配置 SLA 边界用于 histogram_quantile
        this.orderLatencyTimer = Timer.builder("risk.order.latency")
                .description("Order processing latency through risk engine")
                .tags("engine", "risk-engine-01", "tier", "critical")
                .publishPercentiles(0.50, 0.90, 0.99, 0.999)
                .publishPercentileHistogram()
                .sla(Duration.ofMillis(10), Duration.ofMillis(50), Duration.ofMillis(100))
                .register(meterRegistry);
 
        // 2. 规则命中计数器
        this.ruleHitCounter = Counter.builder("risk.rule.hit")
                .description("Risk rule hit count")
                .tag("rule_id", "global")
                .register(meterRegistry);
 
        // 3. 规则执行计数器(用于计算命中率)
        this.ruleEvalCounter = Counter.builder("risk.rule.eval")
                .description("Risk rule evaluation count")
                .tag("rule_id", "global")
                .register(meterRegistry);
 
        // 4. 登录频率计数器
        this.loginSuccessCounter = Counter.builder("risk.login.success")
                .description("Successful login count")
                .register(meterRegistry);
        this.loginFailureCounter = Counter.builder("risk.login.failure")
                .description("Failed login count")
                .register(meterRegistry);
 
        // 5. 反欺诈模型打分时延
        this.fraudModelScoreTimer = Timer.builder("risk.fraud.score.latency")
                .description("Anti-fraud model scoring latency")
                .publishPercentiles(0.50, 0.99)
                .register(meterRegistry);
 
        // 6. 活跃风险事件 Gauge
        this.activeRiskEvents = new AtomicInteger(0);
        Gauge.builder("risk.events.active", activeRiskEvents, AtomicInteger::get)
                .description("Number of active risk events requiring review")
                .register(meterRegistry);
    }
 
    public void recordOrderLatency(long latencyMs, String symbol, String engine) {
        // 动态 Tag 需要谨慎使用,避免高基数问题
        // 建议 symbol 只保留主流交易对,或做分桶处理
        orderLatencyTimer.record(latencyMs, TimeUnit.MILLISECONDS);
    }
 
    public void recordRuleHit(String ruleId, String severity) {
        meterRegistry.counter("risk.rule.hit", "rule_id", ruleId, "severity", severity).increment();
    }
 
    public void recordRuleEval(String ruleId, String severity) {
        meterRegistry.counter("risk.rule.eval", "rule_id", ruleId, "severity", severity).increment();
    }
 
    public void recordFraudScoreLatency(long latencyMs, String modelVersion) {
        // 注意:modelVersion 如果频繁变更, cardinality 会很高,建议作为 Tag 还是 Field 需权衡
        fraudModelScoreTimer.record(latencyMs, TimeUnit.MILLISECONDS);
    }
 
    public void incrementActiveRiskEvent() {
        activeRiskEvents.incrementAndGet();
    }
 
    public void decrementActiveRiskEvent() {
        activeRiskEvents.decrementAndGet();
    }
}

在业务代码中使用(Aspect / Interceptor 模式):

package com.大型加密货币交易所.risk.aspect;
 
import com.大型加密货币交易所.risk.metrics.RiskMetricsRegistry;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class RiskEngineMetricsAspect {
 
    private final RiskMetricsRegistry metrics;
 
    public RiskEngineMetricsAspect(RiskMetricsRegistry metrics) {
        this.metrics = metrics;
    }
 
    @Around("@annotation(com.大型加密货币交易所.risk.annotation.MonitoredRiskRule)")
    public Object aroundRiskRule(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        String ruleId = extractRuleId(pjp);
        String severity = extractSeverity(pjp);
 
        metrics.recordRuleEval(ruleId, severity);
 
        try {
            Object result = pjp.proceed();
            // 假设返回对象包含 isHit() 方法
            if (result instanceof RuleResult rr && rr.isHit()) {
                metrics.recordRuleHit(ruleId, severity);
            }
            return result;
        } finally {
            long latency = System.currentTimeMillis() - start;
            // 记录规则执行延迟
            metrics.recordOrderLatency(latency, "N/A", "risk-engine-01");
        }
    }
 
    // ... helper methods
}

3.3 PromQL 查询示例(风控监控告警)

PromQL(Prometheus Query Language)是 Prometheus 的查询语言,专为时序聚合设计。

1. 计算交易 QPS(每秒请求率):

# 过去 5 分钟,按交易对聚合的每秒订单数
sum(rate(risk_order_latency_count[5m])) by (symbol)

# 过去 1 分钟,全局 QPS
sum(rate(risk_order_latency_count[1m]))

2. 计算 P99 延迟:

# 基于 histogram 计算 P99(要求 Timer 启用了 publishPercentileHistogram)
histogram_quantile(0.99,
  sum(rate(risk_order_latency_bucket[5m])) by (le, engine)
)

# 基于预计算的 percentile(如果启用了 publishPercentiles)
# Micrometer 会导出 risk_order_latency{quantile="0.99"}
risk_order_latency{quantile="0.99", tier="critical"}

3. 风控规则命中率趋势:

# 过去 5 分钟,各规则命中率
sum(rate(risk_rule_hit_total[5m])) by (rule_id)
/
sum(rate(risk_rule_eval_total[5m])) by (rule_id)

# 命中率低于 1% 的规则(可能是规则失效或配置错误)
(
  sum(rate(risk_rule_hit_total[1h])) by (rule_id)
  /
  sum(rate(risk_rule_eval_total[1h])) by (rule_id)
) < 0.01

4. 异常检测:延迟突增(Z-Score 简化版):

# 当前 P99 延迟相比过去 1 小时的均值突增 3 倍以上
(
  histogram_quantile(0.99, sum(rate(risk_order_latency_bucket[2m])) by (le, engine))
  /
  avg_over_time(
    histogram_quantile(0.99, sum(rate(risk_order_latency_bucket[2m])) by (le, engine))[1h:2m]
  )
) > 3

5. 用户登录频率异常(配合 Recording Rule):

# 假设已预聚合为每分钟登录次数
# 单个用户过去 10 分钟登录次数突增(可能暴力破解)
(
  sum(rate(risk_login_success_total[10m])) by (user_id)
  /
  sum(rate(risk_login_success_total[1h])) by (user_id)
) > 5

3.4 InfluxDB Flux 查询示例(风控时序分析)

Flux 是 InfluxDB 2.x 的查询语言,功能比 PromQL 更通用(支持 JOIN、透视等)。

// 查询过去 1 小时,各风控引擎的 P99 延迟趋势
from(bucket: "risk_monitor")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "risk_order_latency")
  |> filter(fn: (r) => r._field == "p99")
  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
  |> yield(name: "p99_trend")

// 查询规则命中率(需要 JOIN hit 和 eval)
hit = from(bucket: "risk_monitor")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "risk_rule_hit")
  |> aggregateWindow(every: 5m, fn: sum, createEmpty: false)
  |> set(key: "_join_key", value: "rule")

eval = from(bucket: "risk_monitor")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "risk_rule_eval")
  |> aggregateWindow(every: 5m, fn: sum, createEmpty: false)
  |> set(key: "_join_key", value: "rule")

join(
  tables: {hit: hit, eval: eval},
  on: ["rule_id", "_time"]
)
  |> map(fn: (r) => ({
      _time: r._time,
      rule_id: r.rule_id,
      hit_rate: r._value_hit / r._value_eval * 100.0
  }))
  |> yield(name: "rule_hit_rate")

3.5 完整 Demo:交易监控指标上报与告警规则

docker-compose.yml(本地测试环境):

version: '3.8'
services:
  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    environment:
      - INFLUXDB_DB=risk_monitor
      - INFLUXDB_ADMIN_USER=admin
      - INFLUXDB_ADMIN_PASSWORD=admin123
    volumes:
      - influxdb-data:/var/lib/influxdb2
 
  prometheus:
    image: prom/prometheus:v2.47.0
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
 
  grafana:
    image: grafana/grafana:10.1.0
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana-data:/var/lib/grafana
 
volumes:
  influxdb-data:
  prometheus-data:
  grafana-data:

prometheus.yml:

global:
  scrape_interval: 10s
  evaluation_interval: 10s
 
scrape_configs:
  - job_name: 'risk-engine'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['host.docker.internal:8080']
        labels:
          env: 'dev'
 
rule_files:
  - /etc/prometheus/rules/*.yml

告警规则 /etc/prometheus/rules/risk_alerts.yml:

groups:
  - name: risk_critical
    rules:
      - alert: RiskEngineHighLatency
        expr: histogram_quantile(0.99, sum(rate(risk_order_latency_bucket[2m])) by (le, engine)) > 100
        for: 2m
        labels:
          severity: critical
          team: risk-platform
        annotations:
          summary: "Risk engine P99 latency > 100ms"
          description: "Engine {{ $labels.engine }} P99 latency is {{ $value }}ms"
 
      - alert: RiskRuleHitRateAnomaly
        expr: |
          (
            sum(rate(risk_rule_hit_total[10m])) by (rule_id)
            /
            sum(rate(risk_rule_eval_total[10m])) by (rule_id)
          ) > 0.5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Risk rule {{ $labels.rule_id }} hit rate is abnormally high"
 
      - alert: FraudModelScoreLatencyHigh
        expr: histogram_quantile(0.99, sum(rate(risk_fraud_score_latency_bucket[5m])) by (le)) > 500
        for: 3m
        labels:
          severity: critical
        annotations:
          summary: "Fraud model scoring P99 > 500ms, blocking order flow"

4. 业界案例

4.1 阿里巴巴:双 11 交易峰值下的时序存储架构

背景:阿里巴巴在双 11 期间需要监控数百万容器、数万微服务的实时指标,峰值时写入量达到每秒数亿个数据点。

架构演进:

  1. 早期:使用 OpenTSDB + HBase。HBase 的 Compaction 在高峰期造成毛刺,且 HBase Region 分裂期间查询不稳定。
  2. 中期:自研 HiTSDB(High Performance Time Series Database),基于 LSM-Tree + SSD 优化,支持分布式集群。
  3. 当前:演化为 Lindorm 时序引擎,采用云原生架构:
    • 写入层:多节点无状态写入网关,支持 Line Protocol。
    • 存储层:基于 Raft 的多副本 Shard,支持冷热分层(热数据 SSD,冷数据 OSS)。
    • 查询层:支持 SQL-like 查询和 PromQL 兼容语法。
    • 降采样:自动按策略降采样,7 天内的数据精度 10 秒,30 天精度 1 分钟,1 年精度 1 小时。

踩过的坑:

  • Tag 滥用导致 OOM:某业务线将 trace_id 作为 Tag 写入, cardinality 瞬间突破千万级,导致倒排索引内存耗尽,整集群雪崩。修复方案:将 trace_id 改为 Field,只索引关键维度(服务名、机房)。
  • Compaction 引发延迟毛刺:旧版本的 Compaction 与写入共用 I/O 线程池,在数据量大时造成写入延迟飙升到秒级。修复方案:引入独立的 Compaction 线程池和 I/O 隔离(cgroups + ionice)。
  • 时间线膨胀(Series Churn):K8s 环境下 Pod 频繁启停,每个 Pod 产生新的时间线,Series 数量无限增长。修复方案:引入 Series 限速和自动过期机制,同时优化索引结构为内存 + 磁盘混合索引。

4.2 字节跳动:万亿级监控指标与 VictoriaMetrics

背景:字节跳动内部监控系统需要处理超过 10 亿条活跃时间线,每日新增万亿级数据点,覆盖抖音、TikTok、飞书等全产品线。

架构选择:

  • 早期使用 Prometheus 联邦集群(Federation),但随着规模增长,联邦方案的查询复杂度和存储碎片化无法忍受。
  • 最终大规模迁移到 VictoriaMetrics(兼容 PromQL 的时序数据库,单机性能是 Prometheus 的 10 倍以上)。
  • 架构为 VictoriaMetrics Cluster(vminsert -> vmstorage -> vmselect),配合 vmagent 做边缘采集。

风控场景的实践:

  • 反欺诈实时看板:利用 VictoriaMetrics 的即时查询能力(Instant Query),在 Grafana 上展示每秒的风控拦截率、模型推理延迟、特征服务命中率。
  • 高基数处理:风控规则 ID 有数万个,user_id 更是海量。字节的做法是将 user_id 级别的高基数据下沉到 ClickHouse(OLAP),而 VictoriaMetrics 只保留聚合后的指标(如按规则 ID、按地区、按风险等级)。
  • Recording Rule 大规模应用:预计算了超过 10 万个 Recording Rule,将常用查询的响应时间从秒级降到毫秒级。

踩过的坑:

  • 拉取模式(Pull)的网络瓶颈:vmagent 拉取数万目标时,TCP 连接数爆炸。解决方案:采用 Pushgateway 模式或 vmagent 的 Stream Aggregation 在边缘做预聚合后再上报。
  • 数据回溯(Backfilling)困难:当补录历史数据时,VictoriaMetrics 的 vmstorage 需要重建索引,造成 CPU 飙升。解决方案:限制回溯速率,使用 vmctl 做离线导入而非实时写入。
  • Churn 导致索引膨胀:微服务版本频繁发布,每个新版本产生新的 version Tag 组合。解决方案:将 version 从 Tag 中移除,改为日志字段,监控只看服务名维度。

5. 业务场景对照与注意事项

5.1 风控 / Risk 场景如何应用

时序数据库在风控系统中不是"可选项",而是支撑实时决策和事后分析的核心基础设施。

风控场景时序数据模型查询模式技术选型建议
交易 QPS/TPS 实时监控Measurement: trade_throughput, Tags: symbol, engine, Fields: qps, tps实时仪表盘,rate() 聚合Prometheus + Grafana
风控规则命中率趋势Measurement: rule_hit, Tags: rule_id, severity, Fields: hit_count时间范围聚合,同比环比InfluxDB / VictoriaMetrics
用户行为频率聚合Measurement: user_action, Tags: action_type, region, Fields: user_id(Field 非 Tag)高频滑动窗口计数ClickHouse + 物化视图(高基数)
延迟 P99/P999 监控Measurement: engine_latency, Tags: engine, method, Fields: 用 Histogramhistogram_quantile()Prometheus
反欺诈模型打分时延Measurement: fraud_score_latency, Tags: model_version, feature_set, Fields: latency_ms阈值告警,延迟分布InfluxDB + Flux
资金流转异常检测Measurement: fund_flow, Tags: currency, channel, Fields: amount, count时间序列异常检测(ARIMA / Prophet)InfluxDB + 外部算法引擎

关键设计原则:

  1. Metric 与 Trace 分离:时序数据存储聚合指标(秒级/分钟级),原始 Trace(单笔订单全链路)应放在 Jaeger/ClickHouse,不要试图用 TSDB 存储 Trace。
  2. 维度设计决定生死:
    • Tag 维度控制在 5 个以内。
    • 避免将用户 ID、订单 ID、IP 地址作为 Tag。
    • 如果必须按用户分析,采用"高基数据走日志/OLAP,低基聚合指标走时序库"的分层架构。
  3. TTL 与成本:
    • 原始数据:7 天(SSD)。
    • 分钟级降采样:30 天(SSD)。
    • 小时级降采样:1 年(对象存储)。
  4. 告警与查询解耦:
    • 告警用 Recording Rule 或 CQ 预聚合后的数据,确保告警检查在毫秒级完成。
    • ad-hoc 查询走原始数据,但要限制时间范围(如最多查 6 小时)。

5.2 常见误区 vs 正确做法

❌ 常见误区✅ 正确做法原因
把时序数据库当万能数据库,存储原始日志和用户行为明细时序库存聚合指标,原始明细走日志系统 / OLAPTSDB 的压缩和索引针对时间序列优化,不适合大文本和高基数明细
所有字段都设为 Tag,方便任意维度查询严格区分 Tag(索引,低基数)和 Field(值,高基数或数值)Tag 进入倒排索引,高基数会导致内存爆炸和查询退化
不做降采样,期望随时查询 3 年前的每秒数据配置多级 Retention 和 Continuous Query / Recording Rule存储成本随时间线性增长,历史查询性能断崖式下降
在 Tag 中使用动态生成的 UUID、TraceID、UserID高基数字段放入 Field,或在应用层做分桶(如 user_id % 100)Cardinality 是 TSDB 的第一杀手
使用 InfluxDB 的 SELECT * 做范围查询只选择需要的 Field,带时间范围上限SELECT * 需读取所有 Field 列,且大数据集可能 OOM
Prometheus 单实例存储超过 15 天数据使用 Thanos / Cortex / VictoriaMetrics 做长期存储Prometheus 本地存储为单节点设计,长期存储需远程后端
忽略 WAL 和副本配置,认为"时序数据丢了没关系"关键风控指标配置多副本或远程备份交易监控数据是审计和故障复盘的核心证据

5.3 选型建议(When to use / When NOT to use)

推荐使用 TSDB 的场景:

  • 数据模型天然是"时间 + 维度 + 数值"。
  • 写入远大于更新(append-only,极少 UPDATE/DELETE)。
  • 查询总是带时间范围,且需要做聚合(SUM/AVG/PERCENTILE)。
  • 需要自动的数据过期和降采样。
  • 监控、告警、仪表盘是主要消费方式。

不推荐 / 需要谨慎的场景:

  • 需要复杂的多表 JOIN 和事务一致性(ACID)。此时用关系型数据库或数据仓库。
  • 数据没有明显的时间属性,或时间只是普通字段之一。
  • 需要频繁的随机点查(如 SELECT * WHERE id = 123),而非范围扫描。
  • 高基数字段需要作为查询过滤条件(如"查询用户 A 过去一年的所有操作"),此时 ClickHouse、Druid、StarRocks 更合适。
  • 数据量极小(日增几千条),用 MySQL + 时间索引足够。

大型加密货币交易所 场景下的具体选型建议:

  • 实时交易监控与告警:Prometheus(Pull)+ VictoriaMetrics(长期存储)+ Grafana。PromQL 生态成熟,告警规则与 K8s 原生集成。
  • 风控规则执行分析:InfluxDB IOx 或 ClickHouse。需要灵活的 SQL 查询做规则效果分析,且可能需要 JOIN 规则配置表。
  • 用户行为时序分析(反欺诈):高基数的 user_id 场景下,采用"Kafka -> Flink 预聚合 -> InfluxDB/VictoriaMetrics 存储聚合指标"的架构。原始明细入 Hive/Iceberg。
  • 全球多机房部署:避免单点 Prometheus,使用 Thanos Sidecar + Query 做全局视图,或直接使用 VictoriaMetrics Cluster。

6. FAQ 与高频追问

Q1: 时序数据库和关系型数据库的本质区别是什么?为什么不能用 MySQL 加时序索引来替代?

答:

本质区别在存储布局、写入模型和查询优化目标三个层面:

  1. 存储布局:

    • MySQL InnoDB 是行存储(Row-oriented),B+ Tree 按主键聚簇。即使主键是 (timestamp, tag),数据在磁盘上按行连续存储,查询 SELECT AVG(latency) 仍需读取整行,I/O 放大严重。
    • TSDB 是列存储或混合布局(如 TSM 按 Time Series 分块)。同一列的数据连续存放,压缩率极高( Gorilla 压缩可达 10:1 以上),聚合查询只需读取目标列。
  2. 写入模型:

    • MySQL 的写入是随机 I/O(B+ Tree 的页更新),高并发写入时锁竞争严重。
    • TSDB 基于 LSM-Tree 或类 LSM 结构,写入转换为顺序追加,内存批量合并后刷盘,写入吞吐量高 1-2 个数量级。
  3. 查询优化:

    • MySQL 的优化器为通用 OLTP 设计,对时间范围聚合没有特殊优化。
    • TSDB 的查询引擎内置时间分片、向量化执行、预聚合和降采样路由。例如 Prometheus 的 rate() 函数直接在引擎内计算相邻 counter 差值,无需应用层处理。
  4. 生命周期管理:

    • MySQL 删除旧数据需要执行 DELETE,产生碎片和锁。
    • TSDB 按 Shard 管理时间范围,过期 Shard 整文件删除(或移至冷存),成本极低。

结论:MySQL 可以存时序数据,但在写入吞吐、存储成本和聚合性能上会被专用 TSDB 碾压。类比:用轿车拉货 vs 用卡车拉货,轿车能拉,但效率和经济性不在一个量级。

Q2: InfluxDB 的 TSM 存储引擎原理是什么?它与标准 LSM-Tree 有何不同?

答:

TSM(Time-Structured Merge Tree)是 InfluxDB 为时序数据定制的存储引擎,核心思想继承 LSM-Tree(顺序写 + 后台合并),但在数据结构和压缩算法上有深度优化:

相同点:

  • 写入先写 WAL,再进入内存 Cache(类比 MemTable)。
  • 内存满后刷盘为不可变文件(TSM File,类比 SSTable)。
  • 后台 Compaction 合并小文件为大文件,清理过期/删除数据。

不同点:

  1. 索引结构:

    • 标准 LSM-Tree(如 RocksDB)的索引是全局有序 KV 的 Bloom Filter + Block Index。
    • TSM 维护一个时序专用索引:按 Time Series(Measurement + Tag Set)组织,每个 Series 指向一个或多个数据块(Block)。查询时先通过倒排索引定位 Series ID,再通过 Series Index 找到对应 Block,无需扫描无关数据。
  2. 数据块编码:

    • TSM 将同一 Time Series 同一时间范围的数据组织为 Block。
    • 时间戳使用 Delta-of-Delta 编码:如果数据每秒一个点,第一个差值是 1s,后续差值几乎为 0,可用 1 bit 表示。
    • 浮点值使用 Gorilla XOR 编码:相邻值的二进制 XOR 结果通常前导零和后缀零很多,只需存储中间变化位。
    • 这种编码在监控指标(变化缓慢)上压缩率极高。
  3. Compaction 策略:

    • 标准 LSM-Tree 按层数(Level)合并,每层大小呈指数增长。
    • TSM 按时间范围和文件大小合并。Level 0 是最新数据(时间范围小、未压缩),高层级覆盖更大的时间范围且压缩率更高。这种设计让按时间范围查询只需读取少量高层级文件。
  4. Field 分离存储:

    • TSM 将不同 Field 分开存储为独立的 Block。查询 SELECT field_a 无需读取 field_b,进一步减少 I/O。

Q3: Prometheus 的 Pull 模式有什么优缺点?为什么 Pushgateway 通常不推荐作为默认方案?

答:

Pull 模式的优点:

  1. 控制平面集中:Prometheus Server 决定何时拉取、拉取谁、拉取频率。新增目标只需配置 Service Discovery(如 K8s),无需修改被监控端。
  2. 天然支持多副本去重:如果两个 Prometheus 实例拉取同一个目标,数据各自独立,不会互相干扰。
  3. 健康检测内建:拉取失败本身就是告警条件(InstanceDown),无需额外的 heartbeat 机制。
  4. 易于本地调试:curl localhost:8080/actuator/prometheus 即可看到当前指标状态。

Pull 模式的缺点:

  1. 网络可达性要求高:Prometheus 必须能访问被监控目标,跨 VPC / 防火墙 / 边缘设备时困难。
  2. 短生命周期 Job 监控困难:Batch Job(如定时风控对账任务)可能运行 30 秒就结束,Prometheus 还没来得及拉取就消失了。此时需要 Pushgateway。
  3. 拉取目标过多时的性能瓶颈:单 Prometheus 建议不超过 1000 个拉取目标,大规模需要联邦或分片。

Pushgateway 不推荐作为默认方案的原因:

  • Pushgateway 是临时指标中转站,设计目标是 Batch Job。如果所有服务都 Push,会造成:
    1. 单点瓶颈:所有流量汇聚到 Pushgateway,高可用和扩展性成为问题。
    2. 丢失 Instance 维度:多个实例 Push 到同一个 Group,Prometheus 无法区分哪个实例的数据,InstanceDown 告警失效。
    3. 内存泄漏风险:Pushgateway 不会自动清理过期数据,如果 Job 不主动清理,指标会永远存在。
  • 正确做法:常驻服务用 Pull,Batch Job 用 Pushgateway 并设置 --persistence.file 和 TTL。

Q4: 降采样(Downsampling)和预聚合(Pre-aggregation)有什么区别?分别在什么场景下使用?

答:

维度DownsamplingPre-aggregation
定义将高频原始数据转为低频统计数据,保留维度信息预先计算好查询结果,丢弃原始维度细节
数据量减少数据点数量,但维度数不变数据量大幅减少,因为维度被聚合掉了
灵活性高,仍可按原始维度过滤和下钻低,只能查询预定义的维度组合
存储位置通常在同一数据库的不同 Retention Policy / Bucket可以是同一数据库,也可以是专门的汇总表
典型工具InfluxDB CQ / Task, Prometheus Recording RulePrometheus Recording Rule, Flink 实时聚合, 物化视图

使用场景:

  • Downsampling 适用:你需要查看"过去一年的 CPU 使用率趋势",但不需要每秒的精度。降到 1 小时一个点即可。保留 host、cpu 维度,可以下钻到某台机器。

  • Pre-aggregation 适用:Dashboard 上有一个固定面板显示"全局交易 QPS"。你不需要按 symbol 拆分,每次 sum(rate(...)) 计算代价高。用 Recording Rule 预计算 global_trade_qps,查询时直接取结果。

生产最佳实践:两者通常结合使用。

  • 第一层:原始数据保留 7 天(1 秒精度)。
  • 第二层:Downsampling 到 1 分钟,保留 30 天。
  • 第三层:Pre-aggregation 计算全局/关键维度的聚合值,保留 1 年。

Q5: 高基数(High Cardinality)问题如何解决?在交易系统中,如果必须按 user_id 查询怎么办?

答:

高基数问题的本质是倒排索引的爆炸。时序数据库的索引通常将每个唯一的 Tag 组合映射到一个 Series ID。如果 user_id 有 1 亿个,那就产生 1 亿条时间线,内存和查询成本都不可承受。

解决策略分层:

1. 设计层避免高基数:

  • 将 user_id 从 Tag 移到 Field。查询时使用 |> filter(fn: (r) => r.user_id == "123")。代价是全表扫描,但适合低频查询。
  • 对 user_id 做分桶:user_bucket = hash(user_id) % 1000,只将 user_bucket(1000 个值)作为 Tag。

2. 架构层分流:

  • 指标(Metrics) vs 事件(Events)分离:聚合指标(如每分钟登录失败次数)走 TSDB,单笔用户事件走日志系统(ELK / ClickHouse)。
  • 双层存储:
    • 热数据(最近 1 小时):Kafka + Flink 实时处理,支持 user_id 级别查询。
    • 冷数据(历史):ClickHouse / Druid 按 user_id 分区,支持秒级扫描亿级记录。
    • 聚合指标:VictoriaMetrics / InfluxDB,低基数维度。

3. 引擎层选型:

  • 如果高基数是刚需,考虑 ClickHouse(稀疏索引,不怕高基数)或 Druid(位图索引 + 预聚合)。
  • InfluxDB IOx(基于 Apache Arrow DataFusion)通过列存和向量化执行,对高基数的耐受度比 TSM 好很多。

交易系统中的 user_id 查询方案:

假设需要分析"用户 A 过去 7 天的所有风控触发记录":

  • 不要在 Prometheus / InfluxDB TSM 中以 user_id 为 Tag 存储。
  • 正确架构:
    1. 风控引擎触发时,发送一条 Kafka Event(包含 user_id、rule_id、timestamp、context)。
    2. Flink 实时消费,产出两份数据:
      • 聚合指标:rule_hit_count{rule_id="xxx"} -> VictoriaMetrics(低基数)。
      • 原始事件:写入 ClickHouse,按 user_id + timestamp 排序键分区。
    3. 查询 user_id 明细时,直接查 ClickHouse:SELECT * FROM risk_events WHERE user_id = 'A' AND ts > now() - 7d。
    4. 查询全局趋势时,查 VictoriaMetrics 的预聚合指标。

这种分层架构是大型交易平台的通用实践:TSDB 负责"看趋势",OLAP 负责"查明细"。

Q6: 在交易监控中,如何确保时序数据的写入不丢点、查询低延迟,同时控制成本?

答:

这是典型的"不可能三角"(不丢数据、低延迟、低成本)在时序场景的工程平衡。实际解法是通过数据分层和差异化 SLA 来破解:

1. 写入可靠性(不丢点):

  • WAL 双写:客户端(如 Micrometer)本地缓存 + 批量上报,服务端先写 WAL 再 Ack。
  • Kafka 缓冲:交易指标先写入 Kafka(3 副本),Consumer 异步刷入 TSDB。即使 TSDB 宕机,数据在 Kafka 中可回放。
  • 关键指标同步写,非关键指标异步写:P99 延迟、资金相关指标同步确认;DEBUG 级别指标可丢。

2. 查询低延迟:

  • 边缘预聚合:在采集端(如 vmagent / Telegraf)配置 Stream Aggregation,上报的已经是 10 秒聚合值,减少服务端计算。
  • Recording Rule 全覆盖:将所有 Dashboard 查询和告警条件转化为 Recording Rule,确保查询命中预计算结果。
  • 内存缓存热点数据:对最近 1 小时的原始数据,TSDB 常驻内存(Prometheus Head Block / InfluxDB Cache)。
  • 查询限流与降级:ad-hoc 查询超过 10 秒自动熔断,返回降采样数据;只影响即席查询,不影响告警。

3. 成本控制:

  • 冷热分层:热数据(7 天)SSD,温数据(30 天)SATA,冷数据(1 年+)对象存储(S3/OSS)。Thanos / Cortex / InfluxDB IOx 都支持 S3 后端。
  • 降采样策略自动化:原始 1 秒 -> 7 天后 1 分钟 -> 30 天后 1 小时。
  • 丢弃低价值指标:定期审计 Metrics,删除未被查询和告警使用的 Series(Prometheus 的 metric_relabel_configs 可配置丢弃)。

大型加密货币交易所 场景下的实践要点:

  • 交易撮合引擎的延迟指标(亚毫秒级)要求秒级精度和秒级查询延迟,这部分数据量小但价值极高,应给予最高 SLA(多副本、SSD、内存缓存)。
  • 用户行为统计(如每分钟登录次数)数据量大但精度要求低(分钟级足够),可接受分钟级查询延迟,适合降采样和冷存。
  • 成本敏感的非核心服务监控,可直接使用远端 SaaS 时序库(如托管 VictoriaMetrics),降低自运维成本。