用 Rust 从零搭一个可观测后端:日志、指标、链路为什么需要三种存储
前面十一篇,每篇都在处理一种数据:
时序库 → 数字,按时间追加
向量检索 → 高维向量
版本控制 → 不可变对象
对象存储 → 不可变大块
CDN → HTTP 响应可观测后端要同时处理三种,而且它们之间几乎没有共同点。
指标(metric):一个数字 + 一组标签 → 可聚合、基数敏感、保留期最长
日志(log): 一行文本 → 不可聚合、基数无限、保留期最短
链路(trace): 一个带父子关系的调用 → 不可聚合、结构复杂、必须采样唯一把它们连起来的是一个 id。 而在讲这个 id 之前,先要把"为什么不能合一"这件事说清楚。
第一步:三种信号的形状差异
这一张表决定了后面所有的架构决策:
| 指标 | 日志 | 链路 | |
|---|---|---|---|
| 单条大小 | 几十字节 | 几百字节 ~ 几 KB | 几百字节 ~ 几 KB |
| 写入速率 | 极高(百万点/秒) | 高(几十万条/秒) | 高(几十万 span/秒) |
| 值是否可聚合 | 是(sum/avg/count/p99) | 否 | 否(duration 可以) |
| 基数 | 受限于标签组合数 | 无限 | 每条唯一 |
| 查询方式 | 时间范围 + 聚合 | 全文检索 + 过滤 | 按 id 取整棵树 |
| 保留期 | 长(月到年,降采样后) | 短(几天到几周) | 短(几天) |
| 能否采样 | 不能(会破坏正确性) | 能(按比例丢) | 必须(成本过高) |
| 索引需求 | 标签索引 | 倒排索引 | 字段索引 |
从这张表里能直接读出一个结论:
"可聚合"和"不可聚合"是这三种数据的根本分界。 指标是唯一的可聚合类型——它的每一个值都是一个聚合结果本身。 而日志和链路是不可聚合的——你没法把两条日志"加起来"。
这个分界带来的第一个后果:指标的存储量随时间增长而收敛,而日志/链路的存储量正比于流量。
指标:
每秒 100 万点写入
但 1 分钟后 → 降采样成 1 个点/分钟 → 60 倍缩小
1 小时后 → 再降采样 → 又 60 倍
所以 1 年前的指标可能只占 1/3600 的空间
日志:
每秒 100 万条写入
一年后还是 100 万条/秒 × 一年的条数
除了"丢掉",没有任何办法缩小"降采样"这个能力只有指标有,因为它可聚合。这就是为什么指标的保留期可以很长,而日志/链路只能短——不是产品决策,是数据性质决定的。
第二步:指标——高基数是这个场景特有的杀手
存储层可以完全复用前面写的时序库(列存 + 时间分区 + 段级剪枝 + 向量化聚合)。但可观测场景引入了一个别处没有的问题:标签基数。
基数是什么,为什么会爆炸
指标名:http_request_duration_seconds
标签: {service="api", method="GET", path="/users/123", status="200"}
问题:path 的取值可能有几百万个(每个用户 id 都是一条不同的 path)
而"标签组合"决定了一条独立的时间线(series):
{service="api", method="GET", path="/users/1", status="200"} ← series 1
{service="api", method="GET", path="/users/2", status="200"} ← series 2
{service="api", method="GET", path="/users/3", status="200"} ← series 3
...
基数 = 各标签取值数的乘积
= 1 × 1 × 1,000,000 × 1 = 100 万条 seriespub struct SeriesKey {
/// 指标名 + 所有标签的组合哈希 —— 这是一条时间线的身份
pub hash: u64,
/// 标签组合(用于查询时的匹配)
pub labels: Vec<(String, String)>,
}
impl MetricStore {
/// 写入一个点:先要把标签组合解析成 series id
pub fn write(&mut self, metric: &str, labels: &[(String, String)], ts: i64, value: f64)
-> Result<()>
{
let key = SeriesKey::from(metric, labels);
// ★ 这一步是问题的核心:
// "标签组合 → series id"这个映射必须存在内存里(否则每次写入都要查磁盘)
// 而基数爆炸时,这个映射本身就是内存杀手
let id = match self.series_index.get(&key.hash) {
Some(id) => *id,
None => {
// 新 series:分配一个 id,写进索引
if self.series_index.len() >= self.max_series {
// ★ 必须有一个硬上限
self.metrics.record_cardinality_limit_hit(metric);
return Err(Error::TooManySeries { metric: metric.to_string() });
}
let id = self.series_index.len() as u32;
self.series_index.insert(key.hash, id);
self.label_store.put(id, &key.labels)?;
id
}
};
self.append_point(id, ts, value)
}
}注意 max_series 那个硬上限——它是必须的,而且必须是一个明确的错误。
为什么必须拒绝而不是"尽力而为"? 因为基数爆炸的后果不是"慢一点",而是:
不加限制的后果:
某个服务上线了一个带 path 标签的指标
→ 一天之内产生 100 万条 series
→ 索引占用几十 GB 内存
→ 写入时哈希表查找变慢 → 写入积压
→ 整个可观测后端被打垮
→ 所有其他服务的监控同时失效这是"一个用户搞垮整个系统"的典型案例(也叫"笛卡尔爆炸"或"高基数攻击")。 而防御方式只有一个:在写入路径上设硬上限,并且明确报错。
三种缓解策略,用途完全不同
| 策略 | 做什么 | 适用 |
|---|---|---|
| 标签值的规范化 | 把 /users/123 变成 /users/:id(在客户端做) |
首选,治本,但要改应用代码 |
| 硬上限 + 拒绝 | 超过 N 条 series 就报错(服务端做) | 必须有,是兜底 |
| 降级成日志 | 高基数数据不聚合,直接按事件存 | 数据本身确实是"事件"而非"指标" |
第一种(规范化)是最有效的,因为它从根上减少了基数:
/// 在指标 SDK 里做路径规范化
pub fn normalize_path(raw: &str) -> String {
// /users/123/orders/45678 → /users/:id/orders/:id
raw.split('/')
.map(|seg| {
if seg.chars().all(|c| c.is_ascii_digit()) {
":id"
} else if is_uuid(seg) {
":uuid"
} else {
seg
}
})
.collect::<Vec<_>>()
.join("/")
}这个函数只有十几行,但它能把基数从"几百万"降到"几十"。 而它的位置很关键——必须在客户端/SDK 里做,而不是在服务端做,因为:
客户端做:
→ 基数从一开始就是低的 → 服务端的索引、内存、网络全部节省
服务端做:
→ 高基数的原始数据已经传过来了 → 网络和解析的开销已经付了
→ 而且服务端要做这个归一化,需要一个"什么算 id"的规则 —— 它不可能知道"在离数据产生最近的地方做归一化"是一条通用原则:日志的字段解析、链路的属性裁剪、指标的标签规范化,都应该在 SDK/agent 那一侧完成,而不是在中心。
高基数应该用"另一种存储"
最后一种策略值得单独说,因为它触及了本质:
如果数据是这样的:
{user_id="1001", action="click", page="/home", ts=...}
{user_id="1002", action="click", page="/cart", ts=...}
这"看起来像指标",但:
① user_id 基数太大,不能当标签
② 而"每个用户的点击"其实是一条**事件**,不是"一个可聚合的数字"
所以它应该存进日志/链路那一层,而不是硬塞进指标。指标的价值来自"聚合",而高基数标签恰好是无法聚合的那一类。 把无法聚合的数据塞进指标系统,得到的不是"更细粒度的指标",而是**"一个被高基数压垮的指标系统"**。正确做法是承认它是事件,用事件的存储去装它。
第三步:日志——倒排索引 + 时间分段
日志层可以复用前面写过的倒排索引 + 段结构,但有几个日志特有的设计点。
索引字段 vs 存储字段
一条日志通常长这样:
{
"timestamp": "2026-10-15T10:00:00.123Z",
"service": "order-api",
"level": "error",
"trace_id": "a3f9c2e1b4d5",
"message": "failed to charge card: timeout after 3000ms",
"user_id": "1001",
"status_code": 504
}这七个字段的"索引需求"完全不同:
| 字段 | 索引方式 | 原因 |
|---|---|---|
| timestamp | 主键的一部分(时间分区) | 每次查询都带时间范围 |
| service / level / status_code | 精确索引(低基数枚举) | 高频过滤条件 |
| trace_id | 精确索引 | 关联查询的入口 |
| user_id | 精确索引(中基数) | 有时要查 |
| message | 分词后的全文索引 | 只在关键词搜索时用 |
pub struct LogIndexSchema {
/// 精确索引的字段(term → 位图)
exact: Vec<String>,
/// 分词索引的字段
analyzed: Vec<String>,
/// 只存储不索引的字段
stored_only: Vec<String>,
}
impl LogIndexSchema {
/// 默认 schema:只有少数字段被精确索引
pub fn default_schema() -> Self {
Self {
exact: vec![
"service".into(),
"level".into(),
"status_code".into(),
"trace_id".into(),
],
// ★ message 只做分词索引 —— 它不该被精确匹配
analyzed: vec!["message".into()],
stored_only: vec![],
}
}
}"message 不做精确索引"这个决定很重要。 因为:
如果给 message 建精确索引:
"failed to charge card: timeout after 3000ms"
← 这条完整的日志文本会成为一个 term
→ 索引里存了整条日志 → 索引和原文一样大(甚至更大,因为有词典)
→ 而实际上没有人会用一条完整日志去精确搜索
如果只做分词索引:
→ "failed" / "charge" / "card" / "timeout" / "3000ms" 各是一个 term
→ 索引小得多,而且支持关键词搜索而 status_code 这种数字字段有一个容易搞混的地方:
// 数字字段如果按"字符串"索引:
// "200" / "404" / "500" 各是一个 term → 没问题
// 但如果是高基数的数字(比如 duration_ms):
// "1" / "2" / ... / "3000" 各是一个 term → 索引爆炸
//
// 所以数字字段要么是低基数(状态码)→ 当枚举索引
// 要么是高基数(耗时)→ 不索引,或者在链路层按区间索引时间分段:让保留期变成"删目录"
pub struct LogStore {
/// 按天分段的根目录
root: PathBuf,
}
impl LogStore {
fn segment_path(&self, day: &str, index: &str) -> PathBuf {
self.root.join(day).join(index)
}
/// 保留期 = 删掉整个目录 —— O(1),不涉及任何数据重写
pub fn apply_retention(&mut self, keep_days: u32) -> Result<usize> {
let cutoff = today() - keep_days;
let mut removed = 0;
for entry in fs::read_dir(&self.root)? {
let entry = entry?;
let day = entry.file_name().to_string_lossy().to_string();
if day < cutoff.format("%Y-%m-%d").to_string() {
// ★ 整目录删除:不需要扫描、不需要 GC 索引
fs::remove_dir_all(entry.path())?;
removed += 1;
}
}
Ok(removed)
}
}"保留期 = 删目录"这个性质非常重要,因为日志的保留期通常很短(几天)——意味着删除是一个高频操作。
如果日志不是按时间分段的,删除"7 天前的数据"就需要:
✗ 没有时间分段:
① 扫描所有段,找出哪些行的时间戳 < cutoff
② 重写所有包含过期数据的段(因为段内数据是混合的)
③ 重建索引
→ 成本正比于"总数据量",而这是每天都在发生的操作
✓ 按天分段:
→ 一天一个目录 → 直接删目录 → O(1)这就是"日志必须按时间分区"的工程理由——不是查询性能(虽然也有),而是删除性能。
写放大是日志系统最大的成本
一条 1KB 的日志,写进去的代价:
① 写原始段 1 KB
② 写倒排索引(每个 term) 约 0.3 KB
③ 写副本(假设 3 副本) × 3 ← 这一项通常是主要成本
④ 段的定期合并(重写) × 2~3
─────────────────────────────────
实际写放大:约 10~20 倍所以在评估日志成本时,"日志量 × 保留期"是严重低估的。 真实的成本是 日志量 × 写放大 × 保留期 / 压缩比。
而写放大里最大的一项通常是"副本",这就是为什么日志的副本策略可以比指标更激进——因为日志收集端本来就有"重试"机制(agent 会缓存未确认的日志),所以丢一小部分副本是可以接受的。
日志的每一个设计决定都要问一句"它的写放大是多少"。 因为日志的数据量天然巨大,任何 ×2 的系数在 TB 级别都是真金白银。 而这也解释了为什么日志系统的实现细节(分段大小、索引粒度、合并策略)比指标系统要讲究得多——指标可以浪费一点空间,日志不行。
第四步:链路——它其实是"日志的一种特例"
这是这一篇里最值得先说明的一个判断。
一条 span 长这样:
{
"trace_id": "a3f9c2e1b4d5",
"span_id": "1f2e3d",
"parent_id": "ab12cd",
"service": "order-api",
"operation": "POST /orders",
"start_time": 1729000000123456,
"duration_ms": 312,
"status": "error",
"attributes": { ... }
}
这和一个结构化日志条目有多大区别?
结构化的字段 → 一样
时间戳 → 一样
索引需求 → 一样(按 service / status / duration 过滤)
文本内容 → 更少(span 的 attributes 通常不是自由文本)所以链路的存储本质上就是"日志存储 + 两个额外的字段(trace_id / parent_id)"。
很多真实系统就是合一的:用同一个宽事件(wide event)存储,只是链路的查询接口会把它组装成树。
pub struct WideEventStore {
/// 按 (时间分区, 索引字段) 组织的段
segments: Vec<Segment>,
/// trace_id 的专用索引(关联查询的高频入口)
trace_index: HashMap<TraceId, Vec<SpanRef>>,
}链路的查询有两种形状,这决定了它会需要额外的索引
查询 A:按 trace_id 取整棵树
→ 先查 trace_index 找到所有 span 的引用
→ 再按 span_id / parent_id 组装成树
→ 这一种只需要 trace_id 索引
查询 B:找"最近 15 分钟里 duration > 1s 的订单服务的请求"
→ 需要 (service, 时间范围) + duration 范围过滤
→ 这一种需要字段索引 + 范围索引
→ 而且返回的是"零散的 span",不是树查询 B 是链路系统真正的价值所在(找慢请求、找错误请求),而它需要的索引和日志是一样的。
查询 A 是"链路的独有能力"——它要靠 trace_id 把一个请求在所有服务里的痕迹串起来。而这个能力完全依赖于"所有服务都传了同一个 trace_id"。
组装成树:一个看似简单但有边界的操作
impl TraceStore {
pub fn assemble_tree(&self, trace_id: TraceId) -> Result<SpanTree> {
let spans = self.fetch_spans(trace_id)?;
if spans.is_empty() {
return Err(Error::TraceNotFound(trace_id));
}
// 按 parent_id 分组
let mut children: HashMap<Option<SpanId>, Vec<&Span>> = HashMap::new();
for span in &spans {
children.entry(span.parent_id).or_default().push(span);
}
// ★ 必须处理"根 span 缺失"的情况
// 原因:采样不完整(见第六步)、或者根 span 还在上报中、或者已经超出保留期
let root = spans.iter().find(|s| s.parent_id.is_none())
.ok_or(Error::RootSpanMissing { trace_id })?;
Ok(SpanTree::build(root, &children, &mut Default::default()))
}
}RootSpanMissing 这个错误是必须显式处理的,因为它经常发生:
为什么会缺根 span:
① 采样不完整(不同服务独立采样 → 有的采了有的没采)
② 根 span 由网关产生,而网关的数据延迟了几秒
③ 根 span 已经超出保留期,但子 span 还没(它们的保留期可能有细微差异)
④ 上报失败(网络抖动,而 span 的上报通常是"尽力而为")如果代码假设"一定有根"(比如直接 unwrap()),那么这四种情况都会变成 500 错误。 而正确的做法是返回"残缺的树",并且显式标记它残缺:
pub struct SpanTree {
pub root: Span,
/// ★ 缺失的父 span(让界面能显示"这里有一段缺失")
pub orphans: Vec<Span>,
/// 是否完整(用于前端提示"此链路不完整")
pub complete: bool,
}链路数据天生是"可能残缺的",因为它来自多个服务的独立上报。 所以它的接口必须能表达"残缺"——而一个不能表达残缺的接口,会在真实的采样和网络条件下变成一堆无意义的错误。
下一篇会看到,这个"残缺"的根源,直接指向可观测系统里最微妙的一个设计:采样。
第五步:关联——trace_id 是唯一的枢纽
三种信号之间的跳转,全部依赖一个"写的时候就带上的 id"。
指标 → 链路:exemplar(在指标点里附一个样例 trace_id)
链路 → 日志:日志里的 trace_id 字段
日志 → 链路:同上exemplar:把聚合后的指标和一个具体样例连起来
你看到的: http_request_duration_seconds 的 p99 在 10:03 飙到了 3 秒
你想知道: 到底是哪个请求慢了?慢在哪个下游?
没有 exemplar:
→ 只能去查 10:03 前后 1 分钟的日志
→ 而那一分钟可能有 5 万个请求
→ 大海捞针
有 exemplar:
→ p99 那个桶里附了一个 trace_id
→ 直接点进去看那条链路的完整调用树pub struct Exemplar {
/// 这个指标点属于哪个桶
pub bucket: BucketLabel,
pub trace_id: TraceId,
/// 这个样例的值(比如 3124ms)
pub value: f64,
pub timestamp: i64,
}但 exemplar 的成本必须算清楚:
如果每个指标点都带一个 trace_id:
指标点原本几十字节 → 加上 trace_id(16 字节)+ 元数据 → 变成 100+ 字节
→ 指标存储量增加 2~3 倍
→ 而指标是"保留期最长"的那一类 → 成本被放大到最长的时间维度上所以 exemplar 必须被采样,而"采样哪些"是一个有明确答案的问题:
| 采样策略 | 效果 |
|---|---|
| 随机 1% | 平均分布,能找到"典型"的慢请求 |
| 只在慢请求/错误时记录 | 精确命中"你最想看的那些请求" |
| 对每个直方图桶各留 1 个 | 能对比"快请求和慢请求的链路差异" |
第二种是性价比最高的,因为慢请求和错误请求才是你去查 exemplar 的原因:
impl ExemplarRecorder {
/// 只对"值得记录"的请求留 exemplar
pub fn maybe_record(&mut self, bucket: BucketLabel, trace_id: TraceId, value_ms: f64) {
// ① 超过阈值(慢)→ 一定记录
if value_ms > self.slow_threshold_ms {
self.exemplars.push(Exemplar { bucket, trace_id, value: value_ms, timestamp: now() });
return;
}
// ② 出错了 → 一定记录(由调用方标记)
if self.error_buckets.contains(&bucket) {
self.exemplars.push(Exemplar { bucket, trace_id, value: value_ms, timestamp: now() });
return;
}
// ③ 其他情况:极低概率随机记录(保留"正常情况"的样本用于对比)
if rand::random::<f64>() < self.sample_rate { // 比如 0.0001
self.exemplars.push(Exemplar { bucket, trace_id, value: value_ms, timestamp: now() });
}
}
}为什么"用时间戳关联"是错的
一个看起来更简单的做法:不做 id 关联,而是"用时间戳在某段时间范围内找对应的日志"。
✗ 错误做法:
指标显示 10:03:00 有慢请求
→ 去日志里查 10:03:00 到 10:03:01 之间的日志
→ 这一秒里可能有 500 条日志,来自 200 个不同的请求
→ 你无法知道哪一条属于那个慢请求时间戳关联的根本问题是"分辨率不够":
同一毫秒内可能有几百个请求
而日志的时间戳精度通常是毫秒(有时甚至只有秒)
→ 时间戳无法唯一标识一个请求
更糟的是:
指标的时间戳是"聚合桶"的时间(比如 10:03:00 代表 10:03:00~10:03:59)
而日志的时间戳是"事件"的时间
两者的语义完全不同 —— 一个是区间,一个是点"关联"这件事必须在写入的时候完成,而不是在查询的时候猜。 因为写入时你有全部的上下文(这个日志属于哪个请求),而查询时你只有时间戳和一堆候选。任何"事后关联"的方案,都建立在一个错误的假设上:时间戳能唯一标识一个事件。
关联的完整链条
把三种信号串起来之后,一次真实的排障看起来是这样:
① 指标告警:order-api 的 p99 从 200ms 涨到 3s(10:03 开始)
↓ 点开这个时间点的 exemplar
② 链路:拿到一个 trace_id,展开调用树
发现 3 秒里有 2.8 秒花在调用 payment-service 上
↓ 从这个 span 里拿到它所属的 service 和时间范围
③ 日志:按 trace_id 查这个请求在整个链路里的所有日志
发现 payment-service 报了 "connection pool exhausted"
↓
④ 结论:payment-service 的连接池被打满,导致 order-api 超时这条链路能走通的前提是:每一步都有一个"写时留下的 id"。 指标点里有 trace_id,span 里有 trace_id 和 service,日志里有 trace_id。缺任何一环,跳转都会断。
可观测性系统的核心不是"存了三种数据",而是"三种数据之间能互相跳转"。 而跳转的能力必须在数据被写入的那一刻就确定下来——这也是为什么 OpenTelemetry 这类标准最重要的贡献不是协议,而是"统一了 trace_id 的传播方式"。
第六步:采样——三种信号的采样策略完全不同
采样是可观测系统里最微妙的设计,因为三种信号的答案完全相反。
指标:不能采样
指标本身就是聚合结果:
http_requests_total{status="200"} = 12345
如果对它采样(比如只记录 50% 的请求):
→ 计数变成 12345 / 2(如果采样率已知,可以乘回去 —— 但误差会累积)
→ 而 p99 这类分位数完全无法通过采样恢复
结论:指标层不采样。它的"降采样"(rollup)是另一回事 ——
那是"把多个点聚合成一个点",是无损的(对可合并的聚合而言)。"降采样"和"采样"是两个完全不同的词,但它们经常被混用:
| 词 | 做什么 | 是否损失信息 |
|---|---|---|
| 降采样(rollup) | 1 分钟 60 个点 → 1 个小时 1 个点(存 sum/count/min/max) | 不损失(对可合并聚合而言) |
| 采样(sampling) | 100 个请求只记录 1 个 | 损失(但可以按比例估计) |
指标可以做降采样,因为它可聚合。日志和链路不能降采样(因为不可聚合),只能采样。
日志:可以按比例丢,但要分级
pub struct LogSampler {
/// 每个服务的采样率
rates: HashMap<String, f64>,
}
impl LogSampler {
pub fn should_keep(&self, record: &LogRecord) -> bool {
// ★ 分级采样:错误的日志永远不丢
match record.level {
Level::Error | Level::Fatal => true, // 100% 保留
Level::Warn => rand::random::<f64>() < 0.5, // 50%
Level::Info => {
let rate = self.rates.get(&record.service).copied().unwrap_or(1.0);
rand::random::<f64>() < rate
}
Level::Debug | Level::Trace => rand::random::<f64>() < 0.01, // 1%
}
}
}"错误日志 100% 保留"这一条几乎是必须的——因为错误日志的量通常只占总量的一小部分,而它的价值最高。 丢掉错误日志省不下多少空间,但会让你在最需要的时候什么都查不到。
链路:必须采样,而且"整棵树一起采"
链路的成本结构决定了它必须采样:
一个请求可能产生 20 个 span(跨 5 个服务,每个服务几个操作)
如果每秒 10 万个请求 → 每秒 200 万个 span
每个 span 约 500 字节 → 每秒 1 GB
→ 一天 86 TB
→ 完全不现实而采样链路有一个必须守住的约束:
✗ 错误:每个服务独立决定"这个 span 要不要上报"
→ 服务 A 采了它的 span,服务 B 没采
→ trace 树变成残缺的(中间缺一层)
→ 你看到的是"一个孤立的 span",无法理解调用关系
✓ 正确:整条 trace 一起采或不采
→ 决策依据是 trace_id
→ 所有服务对同一个 trace_id 算出同一个答案"所有节点对同一个 trace_id 算出同一个答案"的实现,就是哈希:
/// 头部采样:在请求入口决定"这条 trace 采不采"
pub struct HeadSampler {
/// 目标采样率(比如 0.01 表示 1%)
rate: f64,
}
impl HeadSampler {
/// ★ 用 trace_id 的哈希做决策 —— 所有服务算出来一样
/// 而且不需要任何协调、不需要共享状态
pub fn should_sample(&self, trace_id: TraceId) -> bool {
// 把 trace_id 的低 64 位映射到 [0, 1)
let hash = fxhash64(trace_id.as_bytes());
let normalized = (hash as f64) / (u64::MAX as f64);
normalized < self.rate
}
}这个函数的美妙之处在于它是纯函数: 输入是 trace_id,输出是布尔值,没有任何共享状态、没有协调、没有网络调用。 所以:
- 任何一个服务都能独立算出同样的答案(只要采样率配置一致)
- 采样决策可以传播(网关把决定写进请求头,下游直接读,不需要重算)
- 可以在入口就决定(避免产生那些最终会被丢掉的 span)
"用确定性哈希代替协调"这个手法在这个系列里出现过好几次: 一致性哈希(决定数据放哪)、分片(决定哪个 worker 处理)、以及这里的采样决策。它们的共同点是:把"需要协商的决定"变成"由输入唯一确定的函数"。
头部采样 vs 尾部采样
头部采样(head sampling)在入口决定,而它有一个无法回避的缺陷:
在入口决定的时候,你只知道:
✓ trace_id
✓ 请求的路径和方法
✗ 这个请求最后会不会慢
✗ 这个请求最后会不会出错
✗ 它会不会调用到一个有问题的下游
而"慢"和"出错"恰恰是绝大多数链路查询在找的东西。
→ 1% 的头部采样里,可能只包含 1% 的慢请求
→ 而你想看的是"所有慢请求"尾部采样(tail sampling)解决了这个问题:
pub struct TailSampler {
/// 先收集完整的 trace 再决定 —— 需要一个缓冲区
buffer: HashMap<TraceId, BufferedTrace>,
/// 缓冲区最长保留时间
decision_delay: Duration, // 比如 30 秒
}
impl TailSampler {
/// 收到一个 span:先缓冲,不做决定
pub fn on_span(&mut self, span: Span) {
let trace = self.buffer.entry(span.trace_id).or_default();
trace.spans.push(span);
trace.first_seen = trace.first_seen.min(now());
}
/// 定期对"已经结束足够久"的 trace 做决策
pub fn make_decisions(&mut self) -> Vec<BufferedTrace> {
let cutoff = now() - self.decision_delay;
let mut kept = Vec::new();
let mut dropped = 0usize;
self.buffer.retain(|_trace_id, trace| {
if trace.first_seen > cutoff {
return true; // 还没到决策时间
}
// ★ 决策依据是"整条 trace 的特征",而不是某个 id 的哈希
let keep = trace.has_error() // 有错误 → 一定留
|| trace.max_duration_ms() > 1000 // 超过 1 秒 → 留
|| trace.span_count() > 50 // 异常多 span → 留
|| rand::random::<f64>() < 0.01; // 剩下 1% 随机留
if keep {
kept.push(trace.clone());
} else {
dropped += 1;
}
false // 决策完成,从缓冲区移走
});
self.metrics.record_dropped(dropped);
kept
}
}代价非常明确:
| 头部采样 | 尾部采样 | |
|---|---|---|
| 决策时机 | 请求入口 | trace 结束后(延迟几十秒) |
| 决策依据 | 只有 trace_id | 整条 trace 的全部特征 |
| 内存成本 | 无 | 需要缓冲所有 trace(可能几 GB) |
| 能保留"所有错误"吗 | ✗(只能保留 1% 的错误) | ✓ |
| 实现复杂度 | 低 | 高(缓冲、超时、决策、丢弃) |
| 采样率 | 固定 | 动态(错误多的时候采得多) |
尾部采样的内存成本是最容易被低估的:
每秒 10 万个请求 × 决策延迟 30 秒 = 300 万个 trace 在缓冲区里
每个 trace 平均 20 个 span × 500 字节 = 10 KB
→ 缓冲区需要 30 GB 内存所以尾部采样在实践中通常配合"两级策略":
第一级(各服务本地):头部采样,但采样率较高(比如 50%)
→ 先把数据量砍一半,减少缓冲压力
→ 而且是"整条 trace 一致"的(用 trace_id 哈希)
第二级(汇聚点):尾部采样,从 50% 里挑出"值得保留的"
→ 用"有错误 / 慢 / 异常"这些条件
→ 最终保留 1~5%
总成本:50% 的传输 + 30 GB 缓冲 + 1~5% 的存储采样的本质问题是"在信息不足的时候做决定,还是在资源有限的时候做决定"。 头部采样在信息不足时决定(便宜但可能丢重要的),尾部采样在资源充分时决定(贵但能精确挑选)。而两级策略就是把两者的优点叠起来——它承认了"你想要的信息只有等到最后才有",同时把"等"的成本控制在可承受范围内。
第七步:成本模型——可观测性最大的问题
这一节要讲的事情很朴素,但它是这类系统能否持续运行的决定因素:
一家中等规模的公司,可观测数据的量级:
指标:每秒 500 万个点 → 每天约 4300 亿点(降采样前)
日志:每秒 20 万条 → 每天约 170 亿条
链路:每秒 5 万个请求 × 20 span = 100 万个 span → 每天 860 亿个
以每条/每点平均 200 字节计:
日志:170 亿 × 200B = 34 TB/天 ← 数量级最大的
链路(全采样):860 亿 × 500B = 430 TB/天 ← 不采样根本不可能所以"要不要采样"不是一个可选项,而是一个前提。
三个降成本的手段,按效果排序
| 手段 | 效果 | 代价 |
|---|---|---|
| 采样 | 直接按比例减少数据量(10x ~ 100x) | 丢失部分可见性 |
| 保留期分级 | 指标 2 年(降采样后很小)、日志 7 天、链路 3 天 | 老数据查不到 |
| 降采样 | 指标的长期存储缩小几十到几千倍 | 只有指标能做 |
保留期的分级在实践中是"按信号类型"定的,而依据就是前面那张表:
指标:保留 2 年(降采样到 1 小时后,一年的数据量约等于一周的原始数据)
日志:保留 7 天(它的价值衰减极快 —— 排查故障几乎不用超过一周的日志)
链路:保留 3 天(比日志更短,因为链路的数据量更大)而"保留期短"还有一个隐含的代价必须说清楚:
日志保留 7 天意味着:
→ 一个"每周出现一次"的间歇性故障,你永远只能看到一次
→ 一个"一个月前开始出现"的趋势,你无法对比
→ 季度复盘时,只有指标可用,日志全部没了所以"缩短保留期"从来不是一个纯粹的成本决策,它同时决定了"你能回答哪些问题"。而这个取舍必须显式地告知使用方——否则人们会以为自己能查一年的日志。
写放大:必须被测量,而不是被假设
前面提到日志的真实成本是 数据量 × 写放大。而写放大必须被测量:
pub struct WriteAmplificationMetrics {
/// 摄入的原始字节
pub bytes_ingested: u64,
/// 实际写到存储的字节(含索引、副本、合并重写)
pub bytes_written: u64,
}
impl WriteAmplificationMetrics {
pub fn ratio(&self) -> f64 {
self.bytes_written as f64 / self.bytes_ingested as f64
}
}这个比值必须被当成一等指标看待,因为它是唯一的成本杠杆:
如果比值是 15(一个常见的数字):
减少 10% 的摄入量 → 直接减少 10% 的磁盘写入
优化段大小 / 合并策略 → 可能把比值从 15 降到 8 → 成本降一半而它也是"配置调整有没有效果"的唯一反馈。 改了段大小、改了合并策略、改了索引字段——这些调整的效果全部体现为这个比值的变化。
可观测系统本身的"可观测"程度,决定了它能不能被持续优化。 一个不知道自己写放大是多少的日志系统,只能通过"加磁盘"来应对增长——而被测量的系统,可以通过调整参数把成本压下来。这是"给自己装仪表盘"的直接收益。
第八步:查询层——不要假装三种存储是一样的
最后一个设计问题是:三种数据在三种存储里,查询怎么做?
一个很自然的想法是"设计一个统一的查询语言,让它能查所有信号"。 但这个想法有一个陷阱:
✗ 陷阱:假装三种存储的能力一样
比如提供一个统一的 "GROUP BY" 语法
→ 用户会对日志做 GROUP BY(因为它"语法上支持")
→ 而日志不可聚合 → 要么报错,要么给出错误的结果正确做法是让查询语言"知道"每种存储的能力边界,并且显式地表达它们:
pub enum QuerySource {
/// 指标:支持聚合、支持降采样、不支持全文检索
Metrics {
metric: String,
filter: LabelFilter,
/// 聚合方式 —— 只有这里支持
aggregation: Option<Aggregation>,
step: Option<Duration>,
},
/// 日志:支持全文检索和过滤,不支持聚合
Logs {
filter: LogFilter,
full_text: Option<String>,
/// 只能排序和限制,不能 group by
order: Option<LogOrder>,
limit: usize,
},
/// 链路:支持字段过滤和结构展开
Traces {
filter: SpanFilter,
/// 是否展开成完整的树(而不是返回零散的 span)
expand_tree: bool,
limit: usize,
},
}注意每一种都有自己的字段,而不是被塞进一个通用的参数表:
// ✓ 好的设计:能力显式区分
pub struct LogFilter {
pub services: Vec<String>,
pub levels: Vec<Level>,
pub trace_id: Option<TraceId>,
pub time_range: (i64, i64),
// ★ 注意:没有 aggregation 字段 —— 因为日志不支持
}
// ✗ 坏的设计:一个通用的 filter,让用户自己猜哪些字段有效
pub struct GenericFilter {
pub fields: HashMap<String, String>,
pub aggregation: Option<Aggregation>, // ← 对日志来说这个字段无意义但语法上存在
}"类型系统能表达的约束,就不要留给文档去说"。 如果日志不支持聚合,那就让它的查询结构里没有这个字段——这样用户在编译期就知道自己越界了,而不是在运行时拿到一个错误的结果。
下推:让查询在存储层就完成大部分工作
无论查哪种存储,下推的原则都是一样的:
impl QueryEngine {
/// 把一个统一查询翻译成某个存储能执行的计划
pub fn plan(&self, q: &Query) -> Result<PhysicalPlan> {
match q.source {
QuerySource::Metrics { .. } => {
let mut plan = PhysicalPlan::new();
// ① 时间范围下推 —— 三种存储都支持(段级剪枝)
plan.push_down(TimeRangePrune { range: q.time_range });
// ② 标签过滤下推 —— 指标用倒排/位图
plan.push_down(LabelFilterPushdown { filter: label_filter });
// ③ ★ 聚合下推 —— 只有指标能做的关键一步
// 如果聚合能在存储层做,就不需要把原始点拉上来
plan.push_down(AggregationPushdown {
agg: aggregation,
step: q.step,
// 如果查询跨越了降采样粒度,就用预聚合表
use_rollup: self.rollup_available(q.time_range, q.step),
});
Ok(plan)
}
QuerySource::Logs { .. } => {
let mut plan = PhysicalPlan::new();
plan.push_down(TimeRangePrune { range: q.time_range });
// ★ 倒排索引过滤:先算出候选文档位图,再取原文
plan.push_down(InvertedIndexProbe { terms: extract_terms(&full_text) });
// 注意:没有聚合下推 —— 因为日志不可聚合
plan.push_down(LimitPushdown { limit });
Ok(plan)
}
QuerySource::Traces { .. } => {
let mut plan = PhysicalPlan::new();
plan.push_down(TimeRangePrune { range: q.time_range });
plan.push_down(SpanFieldFilter { filter });
if expand_tree {
// ★ 这一步特殊:先按 trace_id 聚成一组,再组装成树
plan.push_down(GroupByTraceId);
plan.push_up(AssembleSpanTree);
}
Ok(plan)
}
}
}
}三种存储的下推能力对比(这个表就是"为什么不能用一个通用引擎"的答案):
| 下推能力 | 指标 | 日志 | 链路 |
|---|---|---|---|
| 时间范围剪枝 | ✓ | ✓ | ✓ |
| 字段/标签过滤 | ✓(位图) | ✓(倒排) | ✓(字段索引) |
| 全文检索 | ✗ | ✓ | ✗ |
| 聚合 | ✓ | ✗ | ✗ |
| 范围聚合(p99 之类) | ✓(近似) | ✗ | ✗ |
| 结构展开(组装树) | ✗ | ✗ | ✓(且是"上推"而不是下推) |
| 降采样表 | ✓ | ✗ | ✗ |
统一查询的价值不在于"用一种语法查所有东西",而在于"让用户能在一个界面里跨三种信号跳转"。 而底层应该是三个不同能力的引擎,各自做自己最擅长的事。任何试图把它们抽象成一个通用引擎的设计,最后都会在某个能力的边界上崩溃。
结论
把这个后端拆开之后,它的形状是:
┌─ 指标:可聚合 → 能降采样 → 保留期可以很长
三种信号的分界 ──┼─ 日志:不可聚合 → 只能采样 → 保留期短
└─ 链路:不可聚合 + 结构复杂 → 必须采样 + 可能残缺
┌─ 复用时序库:列存 + 时间分区 + 段级剪枝
指标层 ────────┼─ 独有的杀手:标签基数(必须硬上限 + 客户端规范化)
└─ 高基数不该塞进指标 —— 它其实是"事件"
┌─ 复用倒排索引:精确索引 vs 分词索引 vs 只存储
日志层 ────────┼─ 按时间分段 → 保留期 = 删目录(O(1))
└─ 真正的成本是写放大(含副本和合并重写)
┌─ 本质是"日志 + trace_id + parent_id"
链路层 ────────┼─ 必须能表达"残缺"(采样和网络让它是常态)
└─ 两种查询形状:按 id 取树 / 按条件筛 span
┌─ exemplar:指标 → 链路(要采样,只对慢/错记录)
关联 ──────────┼─ trace_id:链路 ↔ 日志
└─ 关联必须在写入时确定(时间戳关联不可靠)
┌─ 指标不采样(只降采样)
采样 ──────────┼─ 日志按级别采样(错误永不丢)
└─ 链路必须整条采样(用 trace_id 哈希做确定性决策)
→ 头部采样便宜但漏掉慢/错,尾部采样精确但吃内存
┌─ 三种手段:采样 / 保留期分级 / 降采样
成本 ──────────┴─ 写放大必须被测量,不是被假设
└─ 三种存储能力不同,查询语言必须显式表达这个差异五条最值得记住的判断:
- "可聚合"是三种数据的根本分界。 指标可聚合所以能降采样、能长期保留;日志和链路不可聚合,只能采样和短期保留。
- 高基数不该硬塞进指标。 指标的价值来自聚合,而高基数恰好是无法聚合的那一类——正确处理是承认它是事件。
- 链路采样必须"整条一起采"。 用 trace_id 哈希做确定性决策,不需要任何协调,所有服务算出的答案一致。
- 关联必须靠"写时留下的 id",不能靠时间戳匹配。 同一毫秒内有几百个请求,时间戳无法唯一标识。
- 写放大必须被当成一等指标。 它是唯一的成本杠杆,也是"配置调整有没有效果"的唯一反馈。
这五条有一个共同的形状:它们都在回答"哪些信息在数据被写入的那一刻就必须确定下来"。 trace_id、采样决策、索引字段、标签的规范化——这些东西一旦写入完成就再也改不了。 而可观测系统的绝大部分设计质量,都取决于这些"一次性决定"做得好不好。
下一篇是这个系列的收尾,把这些系统里反复出现的接口原则归纳出来。