一次线上排查,用户说下单要两秒。打开监控,网关入口的 p99 确实是两秒,往下看六个服务,每个服务的 p99 都在 80 毫秒以内,数据库也正常。网关团队说是下游慢,下游团队说是网关排队,两边把各自的图表并排放在一起,谁也没说服谁。会议开了两个小时,结论是「再观察一下」。

后来有人把一条完整链路的 span 拉出来,按时间戳算 「子 span 开始减父 span 开始」,算出一个负数,子 span 比父 span 早了 70 毫秒开始。第一反应是埋点写错了,第二反应才发现,几台机器的系统时钟本来就不一致。用不同机器上的时间戳互相相减,得到的数字没有意义。

链路追踪的价值不在于「画一张漂亮的火焰图」,而在于回答一个很具体的问题:这次慢,慢在哪一段。这篇先把 traceId 和 span 讲清楚,再讲时钟偏移这个坑,最后给一套能直接用的定位方法。

七个现象:链路有了,结论还是错的

很多团队已经接了追踪,但排障时仍然靠猜,原因是数据本身有缺陷:时间戳不可比、span 缺失、采样没覆盖到慢请求。下面这些现象,比「没有追踪」更误导人。

现象真实原因第一步查什么
每个服务都说自己快,端到端就是慢时间花在服务之间的排队、连接、序列化,不在服务内部算每个 span 的自身耗时,看父子差值
时间戳相减出现负数跨机器时钟不一致,存在几十毫秒偏移对比各机 NTP 偏移,改用同机时长
链路中间断了一截异步线程池或消息队列没有传递追踪上下文查线程池包装和消息头注入
日志里搜不到 traceId日志模板没带,或者异步日志丢了上下文查日志格式和 MDC 的清理时机
复现时找不到慢请求样本固定比例采样,慢请求正好没被采到查采样策略,是否有慢请求保底采样
span 的开始顺序看起来乱并行调用加时钟偏移,绝对时间不可靠按父子关系和时长还原,不按绝对时间排序
平均延迟正常,用户投诉很多尾延迟高,平均值被大量快请求拉平看 p99 与分实例分布,不看平均值

第一条最典型,它说明「服务自己的监控」和「用户感知」之间隔着一层看不到的成本。每个服务只统计自己处理请求的时间,请求在网络上排队、在连接池里等、在网关里被重试,这些时间没有归属,于是在所有服务的图表上都消失了。

第二条是这一篇的重点。看起来只是一个符号问题,实际会让整套排查方向跑偏:你会以为「子调用比父调用早开始」是代码逻辑错误,去翻业务代码,而真正的问题在时钟同步。

traceId 和 span:一条链路是什么形状

一次请求从进入到返回,会经过多个进程。要把它串起来,需要两样东西:一个全局唯一的编号,和一组描述「每一段工作」的记录。

traceId 是一次请求的全局编号。它在入口生成,之后通过请求头一路传给下游,所有服务的日志和追踪数据都带上它。排障时你只要拿到一个 traceId,就能把散落在六台机器上的记录拼成一条链路。

span 是链路里的一段工作,可以理解为「某个服务在处理这次请求时,从开始到结束的这一段」。每个 span 至少记录:所属的 traceId、自己的 spanId、父 span 的 spanId、开始时间、持续时长、服务名和几个业务标签。span 之间靠父子关系组成一棵树,不靠时间先后。

一次下单请求的 span 树
网关 gw生成 traceId,记录入口耗时
订单 order父 span 是 gw,负责编排
库存 inventory父 span 是 order
支付 pay父 span 是 order

注意这里的关键设计:时长由每个进程用自己的单调时钟测量,而不是用墙上时钟相减。墙上时钟是我们在日历上看到的时间,会被 NTP 调整,可能往前跳也可能往后跳;单调时钟只保证「一直往前走」,不受校时影响。span 记录「持续了多久」,这个数字在同一台机器上测出来是可信的。

上下文传播靠请求头。跨进程调用时,把 traceId 和当前 spanId 放进一个约定好的头,下游读出来,创建自己的子 span。行业里有一个通用的格式叫 traceparent,内容大致是版本、traceId、父 spanId、采样标志四段,用短横线连起来。自研协议也可以,只要保证每个服务都能读能写。

最容易丢上下文的地方是异步。请求进了线程池,换了线程,ThreadLocal 里的 traceId 就没了;消息发到队列,消费端从头开始,父子关系断了。这两处不补,链路就会在中间断一截,而断掉的那一截往往正是最慢的部分。

时钟偏移:为什么时间戳相减会出负数

下面这组数据是一次跨机链路的原始时间戳,每台机器用自己系统时钟记录。先看数字,再看它说明了什么。

原始时间戳(各机自己的钟):
  gw [1000, 1300] 主机=gateway
  order [930, 1200] 主机=order
  inventory [950, 1020] 主机=inventory
  pay [1100, 1250] 主机=pay
父 span gw 开始于 1000,子 span order 开始于 930,子比父早 70ms
用「子开始 - 父开始」算网关自身入口耗时: -70ms(负数,说明跨机相减不可用)
改用每个 span 自己的时长(同机相减,不受时钟偏移影响):
  gw 时长 300ms
  order 时长 270ms
  inventory 时长 70ms
  pay 时长 150ms
  order 自身耗时 = 270 - 70 - 150 = 50ms

网关的 span 从 1000 到 1300,订单服务的 span 从 930 到 1200。按常理,子调用应该晚于父调用开始,可这里子比父早了 70 毫秒。这不是代码写错了,而是订单服务那台机器的钟比网关慢了 70 毫秒。两台机器各自看自己的时间都没问题,放在一起比就错了。

所以跨机的时间戳只能用来做「粗略排序」,不能用来做减法算耗时。真正可信的是每个 span 自己记录的时长:网关 300 毫秒,订单 270 毫秒,库存 70 毫秒,支付 150 毫秒。这些数字都是在各自机器上、用单调时钟测出来的,不受别的机器影响。

有了时长,就能算「自身耗时」:一个 span 的总时长减去它所有子 span 占用的时间,剩下的就是这段代码自己花的。订单 span 270 毫秒,两个子 span 分别是 70 和 150 毫秒,于是订单服务自身的编排、校验、写库等动作合计 50 毫秒。同理,网关 300 毫秒减去订单 270 毫秒,网关自身耗时 30 毫秒。整条链路 300 毫秒里,真正在各服务内部执行的只有 30 加 50 加 70 加 150,剩下的是调用间隙和排队。

时钟偏移有多大,取决于环境。物理机跑着 NTP,通常能控制在几毫秒;虚拟机和容器在高负载下,偏移可能到几十毫秒甚至更多;如果某个环境的 NTP 根本没配,差几秒也不奇怪。这解释了为什么有些团队在测试环境从没遇到过负数,一到生产就出现。

不要用「父 span 结束减子 span 结束」来判断谁先完成,也不要用绝对时间给 span 排序。跨机比较只有父子关系和时长是可靠的。

自身耗时怎么算:串行相减,并行取并集

算自身耗时有一个前提:先分清子 span 是串行还是并行。串行的子调用一个接一个,直接把时长相加再减;并行的子调用同时进行,时间上重叠,相加会重复计算。

串行子 span:
  self = span.duration - sum(child.duration)

并行子 span:
  covered = 子 span 时间区间的并集长度
  self = span.duration - covered

注意:区间用每个 span 自己的开始与时长推出来,
只在同一台机器内比较;跨机时先用父子的相对顺序还原。

举个具体例子。订单服务同时调库存和支付,两个子 span 都是 150 毫秒,但它们是并行的,父 span 只花了 160 毫秒。如果按串行相减,会算出 160 减 300 等于负 140,显然是错的。正确做法是把两个子区间求并集,重叠部分只算一次,得到大约 150 毫秒的覆盖时间,自身耗时约 10 毫秒。

并行的识别不能靠时间戳,因为跨机时间不可比。可靠的办法是看父 span 的子节点里,有没有相互独立的调用,以及它们的时长之和是否明显超过父 span 的时长。如果子时长之和大于父时长,基本可以判定存在并行,这时必须用区间并集,不能直接相加。

还有一类「隐形的子 span」:没有埋点的调用。比如服务里直接查了一次数据库、调了一个没有接追踪的旧系统,这些时间不会出现在 span 树里,于是全部被算进「自身耗时」。看到某个服务的自身耗时异常高,先确认它有没有未埋点的外部调用,别急着怀疑业务代码。

定位顺序可以固定成三步:先看入口总时长,再逐层算自身耗时,找出占比最大的那一层,最后进到那一层看它的子调用和日志。这套顺序的好处是每一步都在缩小范围,而不是六个团队一起猜。

如果链路跨越了消息队列,父子关系不能只看调用,还要看消息的生产和消费。生产端在消息头里写入当前 spanId,消费端用它作为父 span,否则消费这一段会变成一条新的孤立链路,消息在队列里等待的那段时间也无从计算。很多「异步任务慢」的问题查不出来,就是因为这一环断了。

采样与尾延迟:别让平均值骗你

全量采集追踪数据的成本很高。一次下单跨六个服务,每个服务产生几个 span,一天千万次请求就是几亿条记录,存储和传输都吃不消。所以追踪系统通常会采样,只保留一部分链路。

常见采样有两种。按比例采样是在入口决定「这条链路采不采」,实现简单,但慢请求和快请求被采到的概率一样,出问题时可能一条慢链路都没留下。另一种是按尾部特征采样,先缓存一段数据,等链路结束后看它的总时长或错误状态,超过阈值就完整保留。后者的成本高一些,但能保证慢请求有样本。

比较实用的组合是:常规流量按 1% 到 10% 采样,超过设定阈值的慢请求 100% 保留,出错请求 100% 保留。阈值按业务的 p99 来定,比如 p99 是 300 毫秒,就把 500 毫秒以上全部留下。这样既能控制总量,又不会在故障时「没有样本」。

采样决定必须贯穿整条链路。入口决定采,就把采样标志和 traceId 一起放进请求头,下游看到标志后跟着采;否则会出现入口采了、下游没采,链路断成几段,或者反过来,下游自己采了一堆孤立片段。采样标志和 traceId 要当成同一套上下文一起传播。

尾延迟是另一件容易被平均值掩盖的事。假设 99% 的请求 50 毫秒,1% 的请求 2 秒,平均下来只有 70 毫秒左右,看起来很好。但用户遇到的正是那 1%。链路追踪要按 p99、p999 看,而且要按实例看:同一个服务十个实例,可能只有一个实例的 p99 很高,聚合之后被其他九个稀释掉。

尾延迟的来源通常不在业务逻辑,而在排队:连接池等待、线程池排队、垃圾回收停顿、下游某个实例变慢。这些时间段在 span 里表现为「自身耗时偏高」或者「子调用时长偏高」,需要结合实例标签和线程状态一起看。只看一个服务的聚合指标,永远找不到是哪个实例的问题。

落地时要定的几个参数

span 数量上限。一条链路最多保留多少个 span,比如 200 个。循环里调用下游的场景很容易产生几千个 span,不限制会拖垮采集端。超过上限后丢弃低价值的内部 span,保留入口和关键下游。

单 span 标签数量。业务标签不是越多越好。十几个标签乘以几亿条 span,存储成本会翻几倍。只保留能用来过滤的字段,比如用户等级、渠道、实例号,不要塞整段请求体。

上报方式。同步上报会给业务增加延迟,通常用异步批量上报,批量大小几百条、间隔一秒左右。采集端要能承受突发,服务重启时积压的数据会集中上报。

保留时长。原始 span 保留七天到三十天,聚合指标保留更久。排障通常只需要最近几天,长期趋势看聚合指标就够了。

上下文清理。请求结束必须清理线程上的 traceId,否则线程池复用时会串号。清理要放在 finally 里,异步任务要用包装器传递上下文,不要依赖隐式继承。

一个便宜的验收方法:随便挑一个线上慢请求的 traceId,看它能否还原出完整的父子树,并且每个节点的自身耗时加起来接近总时长。差得越多,说明埋点缺口越大。

边界与代价

追踪看不到「没有请求」的时间。消息在队列里等待、定时任务排队、连接在池里闲置,这些时间不属于任何一个 span。端到端慢但所有 span 都正常时,要去查这些「没有埋点的地方」,而不是继续在服务内部找。

它不能替代指标和日志。追踪适合看单次请求的细节,指标适合看整体趋势,日志适合看具体错误。三样各有各的位置,只靠追踪会被采样率和存储成本限制,只靠指标则永远定位不到具体那一次。

埋点是有成本的。每个 span 都要创建对象、记录时间、序列化、上报,高频接口上这些开销会累积。核心链路可以全埋,边缘接口按需埋,不要为了「完整」把每个函数都包一层。

数据本身有隐私风险。span 标签里如果带了用户 ID、手机号、请求参数,追踪系统就变成了一个敏感的数据库。标签要做脱敏和白名单,别把整个请求体塞进去。

时钟问题不会因为有了追踪就消失。追踪只是让你能绕开它,真正的修复仍然要把 NTP 配好、把时钟偏移监控起来。偏移超过阈值的机器应该告警,否则下一次排障还会踩同一个坑。

小系统可以先用日志。三五个服务,用统一的日志格式加一个请求 ID,就能串起大部分问题。追踪系统的部署和维护成本不低,等链路真的长到靠日志串不起来时再上,更划算。

当天可以自验的五件事

  1. 挑一条完整的线上链路,检查是否存在「子 span 开始时间早于父 span」的情况。有的话,先量这几台机器的时钟偏移。
  2. 对同一条链路,把每个 span 的时长减去子 span 时长,看自身耗时加起来是否接近入口总时长。差得多的那段就是埋点缺口。
  3. 检查异步线程池和消息消费端是否传递了 traceId。没有的话,这段链路在追踪里就是断的。
  4. 查当前采样率,并确认慢请求和错误请求是否有保底采样。没有保底的话,故障时大概率没有样本。
  5. 把一个服务的平均延迟和 p99 并排放,再看单实例的 p99。平均正常但 p99 很高,说明问题在尾部,不在整体。

下一篇讲熔断、降级与隔离。追踪能告诉你慢在哪一跳,但知道了之后还得决定:这一跳要不要继续等、要不要直接失败、要不要把它和别的调用隔开。一个下游卡住,为什么能把整个服务甚至全站拖垮,那篇会用一个具体的等待时间账来说明。