短链接跳转延迟突增200ms？（Go HTTP中间件链路追踪全解密）

第一章：短链接系统性能突变现象与问题定位

短链接服务在日常流量中通常表现稳定，但在某些时段会突发性出现响应延迟激增、HTTP 503 错误率飙升或重定向耗时突破 P99=200ms 阈值等异常现象。这类性能突变往往无明显前置告警，且不伴随 CPU 或内存的持续高位占用，属于典型的“隐性雪崩”特征。

常见突变模式识别

流量毛刺叠加缓存穿透：某营销活动触发瞬时百万级短码解析请求，其中约12%为无效或已过期短码，直接击穿 Redis 缓存层，大量请求回源至 MySQL；
分布式锁竞争激化：多实例并发更新同一短码的访问统计（如 UPDATE link_stats SET click_count = click_count + 1 WHERE short_code = 'abc123'），在未加乐观锁或分片计数器情况下引发行锁等待队列堆积；
DNS 解析抖动传导：边缘节点本地 DNS 缓存失效后批量发起上游解析，造成 UDP 端口临时拥塞，表现为 curl -v 中 TCP 连接建立耗时突增至 1.2s+。

快速定位三步法

实时指标下钻：执行以下命令采集突变窗口内关键维度数据：

# 获取最近5分钟各API路径P95延迟及错误率（需Prometheus+Grafana已接入）
curl -s "http://prom:9090/api/v1/query?query=histogram_quantile(0.95%2C%20sum%20by%20(le%2C%20path)%20(rate(http_request_duration_seconds_bucket%7Bjob%3D%22shortlink-api%22%7D%5B5m%5D)))" | jq '.data.result[] | "\(.metric.path) \(.value[1])"'

链路追踪抽样：在 Jaeger UI 中按 http.status_code="503" + service.name="redirect-service" 筛选，观察 span 中 redis.get 和 mysql.query 的 span duration 分布是否呈现双峰；

日志关键词扫描：

zgrep -h "timeout\|lock wait\|too many connections" /var/log/shortlink/*.log.gz | \
awk '{print $1,$2,$NF}' | sort | uniq -c | sort -nr | head -10

关键依赖健康快检表

组件	检查命令	异常信号
Redis	`redis-cli -h cache01 ping && redis-cli info \| grep -E "connected_clients\|blocked_clients"`	`blocked_clients > 50`
MySQL 主库	`mysql -e "SHOW PROCESSLIST" \| grep -E "Locked\|Waiting"`	`State` 列中 `Waiting for table metadata lock` 超过10行
本地 DNS	`dig +short bit.ly @127.0.0.1`	响应时间 > 300ms 或超时

第二章：Go HTTP中间件链路追踪原理剖析

2.1 Go net/http 服务模型与请求生命周期解析

Go 的 net/http 采用单 goroutine per request 模型，基于底层 net.Listener 的阻塞式 Accept + 并发处理。

核心服务启动流程

http.ListenAndServe(":8080", nil) // 使用默认 ServeMux

:8080：监听地址与端口，底层调用 net.Listen("tcp", addr)
nil：表示使用 http.DefaultServeMux 作为路由处理器
启动后进入无限循环：Accept() → Serve() → Handler.ServeHTTP()

请求生命周期关键阶段

阶段	触发点	关键行为
连接建立	`Listener.Accept()`	获取 `net.Conn`，启动新 goroutine
请求解析	`conn.serve()` 内部	调用 `readRequest()` 解析 HTTP 报文头/体
路由分发	`server.Handler.ServeHTTP()`	匹配路径，执行注册的 `HandlerFunc`
响应写入	`ResponseWriter.Write()`	缓冲至 `conn.bufw`，最终 `Flush()` 到 TCP

graph TD
    A[Accept Conn] --> B[Parse HTTP Request]
    B --> C[Match Route in ServeMux]
    C --> D[Invoke Handler.ServeHTTP]
    D --> E[Write Response via ResponseWriter]
    E --> F[Close or Keep-Alive]

2.2 中间件链式调用机制与耗时累积模型

中间件链本质是函数式责任链，每个中间件接收 ctx 和 next，执行自身逻辑后显式调用 next() 推进流程。

耗时注入原理

通过 ctx.start = Date.now() 在首个中间件初始化，并在每个中间件末尾计算 ctx.elapsed = Date.now() - ctx.start。

// 示例：日志中间件（记录单段耗时）
app.use(async (ctx, next) => {
  const start = Date.now();
  await next(); // 执行后续中间件及路由
  ctx.logger.info(`[${ctx.path}] ${Date.now() - start}ms`);
});

逻辑分析：start 在进入时捕获时间戳；await next() 确保等待完整链执行完毕；差值反映该中间件包裹范围内全部子阶段的总耗时。

链式累积特性

阶段	耗时来源
认证中间件	JWT 解析 + DB 查询
限流中间件	Redis 原子计数 + 判断
全局耗时字段	所有前置中间件叠加结果

graph TD
  A[请求入口] --> B[认证中间件]
  B --> C[限流中间件]
  C --> D[业务路由]
  D --> E[响应组装]

每个中间件的 elapsed 是从请求开始到当前阶段结束的累计值
最终响应头中 X-Response-Time 即链尾 Date.now() - ctx.start

2.3 Context 传递与 span 生命周期绑定实践

在分布式追踪中，Context 不仅承载 trace ID 和 span ID，更需与 span 的生命周期严格对齐——span 创建即注入 context，span 结束即清理关联状态。

数据同步机制

使用 Scope 管理当前活跃 span，确保 Context.current() 始终返回与执行线程一致的 tracing 上下文：

try (Scope scope = tracer.spanBuilder("db-query").startActive(true)) {
  // span 自动绑定至当前 Context
  doDatabaseCall(); // 内部调用可安全获取 active span
}
// span 自动结束，context 中 span 引用被清除

逻辑分析：startActive(true) 将 span 注入 Context.root().with(span)，并注册 AutoCloseable 回调；scope.close() 触发 span.end() 并重置 Context 中的 span 引用，避免内存泄漏与跨请求污染。

生命周期关键节点对照表

事件	Context 状态变化	Span 状态
`spanBuilder.startActive(true)`	`Context.with(span)` 覆盖当前线程本地值	STARTED
`scope.close()`	恢复上层 Context（或 root）	ENDED
`span.end()` 显式调用	无自动变更（需配合 Scope）	ENDED

graph TD
  A[创建 SpanBuilder] --> B[调用 startActive true]
  B --> C[Span 启动 + 绑定到 Context]
  C --> D[业务逻辑执行]
  D --> E[Scope.close]
  E --> F[Span.end + Context 恢复]

2.4 OpenTelemetry SDK 在 Go HTTP 中的嵌入式集成

OpenTelemetry SDK 的嵌入式集成强调轻量、无侵入与生命周期对齐。在 Go HTTP 服务中，推荐通过 http.Handler 中间件方式注入追踪能力。

初始化 SDK 并配置 HTTP 传播器

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/trace"
    "go.opentelemetry.io/otel/sdk/resource"
    semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
)

func initTracer() {
    exporter, _ := otlptracehttp.NewClient(
        otlptracehttp.WithEndpoint("localhost:4318"),
        otlptracehttp.WithInsecure(),
    )
    tp := trace.NewTracerProvider(
        trace.WithBatcher(exporter),
        trace.WithResource(resource.MustNewSchemaless(
            semconv.ServiceNameKey.String("go-http-service"),
        )),
    )
    otel.SetTracerProvider(tp)
}

该代码初始化 OTLP HTTP 导出器并注册全局 TracerProvider；WithInsecure() 适用于开发环境，生产应启用 TLS；ServiceNameKey 是资源标识核心字段，影响后端服务发现。

HTTP 中间件自动注入 Span

组件	作用
`otelhttp.NewHandler`	包装 `http.Handler`，自动创建 server span
`propagation.TraceContext`	解析 `traceparent` 头，实现跨进程上下文透传

http.Handle("/api/data", otelhttp.NewHandler(
    http.HandlerFunc(handleData),
    "GET /api/data",
    otelhttp.WithPublicEndpoint(), // 标记为入口点
))

otelhttp.NewHandler 自动捕获请求方法、路径、状态码，并将 traceparent 注入 context；WithPublicEndpoint() 确保根 Span 被正确标记为入口（Entry Span），避免被误判为内部调用。

graph TD A[HTTP Request] –> B{otelhttp.NewHandler} B –> C[Extract traceparent header] C –> D[Start server span] D –> E[Invoke user handler] E –> F[End span with status]

2.5 自定义中间件埋点与延迟指标实时聚合实现

在 Spring Boot WebMvc 环境中，通过实现 HandlerInterceptor 注入毫秒级请求生命周期埋点：

public class LatencyTracingInterceptor implements HandlerInterceptor {
    private static final Timer REQUEST_LATENCY = Metrics.timer("http.request.latency");

    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) {
        req.setAttribute("start_time", System.nanoTime()); // 纳秒精度起点
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest req, HttpServletResponse res, Object handler, Exception ex) {
        long start = (Long) req.getAttribute("start_time");
        long elapsedMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
        REQUEST_LATENCY.record(elapsedMs, TimeUnit.MILLISECONDS); // 自动按分位数聚合
    }
}

逻辑分析：System.nanoTime() 提供高精度单调时钟，规避系统时间回拨风险；Metrics.timer() 内置滑动窗口与百分位统计（p50/p95/p99），无需额外聚合服务。

核心指标维度表

维度	示例值	用途
`uri`	`/api/v1/users`	路由粒度延迟分析
`status`	`200`, `500`	错误率关联延迟诊断
`method`	`GET`, `POST`	方法级性能基线比对

实时聚合流程

graph TD
    A[HTTP Request] --> B[preHandle: 记录纳秒起点]
    B --> C[Controller 执行]
    C --> D[afterCompletion: 计算耗时并上报]
    D --> E[Prometheus 拉取 /actuator/metrics]
    E --> F[Grafana 实时渲染 P95 延迟热力图]

第三章：短链接跳转核心路径性能瓶颈诊断

3.1 Redis 缓存穿透与连接池阻塞的实测分析

缓存穿透指大量请求查询不存在的 key，绕过缓存直击数据库；而连接池阻塞则常因 JedisPool 资源耗尽引发线程等待。

复现缓存穿透场景

// 模拟恶意请求：连续查询不存在的用户ID
for (int i = 0; i < 10000; i++) {
    String key = "user:" + UUID.randomUUID(); // 高熵、永不命中
    String value = jedis.get(key); // 返回 null，触发 DB 查询逻辑
}

UUID.randomUUID() 保证 key 全局唯一且无规律，使 LRU 缓存完全失效；jedis.get() 在未命中时若无布隆过滤器兜底，将 100% 转发至后端 DB。

连接池阻塞关键参数

参数	推荐值	说明
`maxTotal`	200	最大连接数，过低易排队
`maxWaitMillis`	2000	等待超时，超时抛 `JedisConnectionException`

graph TD
    A[客户端请求] --> B{JedisPool.borrowObject()}
    B -->|有空闲连接| C[执行命令]
    B -->|无空闲且未达maxTotal| D[创建新连接]
    B -->|已达maxTotal| E[等待maxWaitMillis]
    E -->|超时| F[抛异常]

3.2 URL 解析与重定向响应构造的 GC 开销验证

在高并发重定向场景下，String.substring() 和 UriComponentsBuilder.fromUriString() 的临时对象创建成为 GC 压力主因。

关键瓶颈定位

每次解析生成 UriComponents 实例（不可变、含 7+ 内部字符串引用）
response.sendRedirect() 隐式触发 StringBuilder 多次扩容（平均 3.2 次/请求）

优化前后对比（JVM G1GC, 10k RPS）

指标	优化前	优化后	降幅
Young GC 频率	42/s	11/s	74%
Promotion Rate	8.7 MB/s	1.3 MB/s	85%

// ✅ 复用预解析模板，避免 runtime 构造
private static final String REDIRECT_TEMPLATE = "https://example.com/v1/redirect?to=%s";
// 替代：response.sendRedirect(constructRedirectUrl(input));
response.setHeader("Location", String.format(REDIRECT_TEMPLATE, 
    URLEncoder.encode(safeTarget, StandardCharsets.UTF_8)));

逻辑分析：跳过 UriComponentsBuilder 全链路对象创建（减少 12 个临时对象），String.format 复用常量模板字符串，URLEncoder 输出直接写入响应头缓冲区，避免中间 String 拷贝。

graph TD
    A[原始URL] --> B[UriComponentsBuilder.fromUriString]
    B --> C[UriComponents.toUri]
    C --> D[response.sendRedirect]
    D --> E[隐式new StringBuilder]
    E --> F[Young GC 压力↑]
    A --> G[模板+URLEncoder]
    G --> H[直接setHeader]
    H --> I[零中间字符串对象]

3.3 DNS 缓存缺失与 TCP 连接复用失效现场复现

当客户端频繁发起新域名请求且本地无缓存时，glibc 的 getaddrinfo() 会触发同步 DNS 查询，阻塞连接池复用路径。

复现关键步骤

启动无 DNS 缓存的容器（--dns=8.8.8.8 --dns-opt ndots:1）
使用 curl -v http://example.invalid/ 强制每次解析
抓包验证：tcpdump -i any port 53 and host 8.8.8.8

DNS 查询阻塞链路示意

# 模拟高并发解析（每请求强制刷新）
for i in {1..5}; do 
  time getaddrinfo -f example.invalid 80 2>/dev/null | head -n1
done

逻辑分析：getaddrinfo 默认启用 AI_ADDRCONFIG，若 /etc/resolv.conf 中 nameserver 响应慢（>5s），将跳过连接池复用逻辑；-f 参数强制忽略系统级 DNS 缓存（如 systemd-resolved），直连上游。

连接复用失效对比表

场景	复用成功率	平均建连耗时	触发条件
DNS 缓存命中	98%	2.1 ms	`/etc/hosts` 存在
DNS 缓存缺失+超时	0%	5200 ms	UDP 53 丢包+重试
TCP Fast Open 启用	41%	1800 ms	kernel ≥ 4.11

graph TD
  A[HTTP Client] --> B{DNS 缓存存在？}
  B -->|否| C[发起 UDP 53 查询]
  C --> D[等待响应或超时]
  D --> E[放弃复用，新建 socket]
  B -->|是| F[复用已有 TCP 连接]

第四章：高并发短链接场景下的链路优化实战

4.1 基于 middleware pipeline 的非阻塞日志采样策略

在高吞吐 Web 服务中，全量日志写入会成为 I/O 瓶颈。Middleware pipeline 天然支持链式、异步、无状态的日志干预。

核心设计原则

采样决策在请求进入 pipeline 早期完成（避免后续中间件副作用）
日志写入委托给独立任务队列（如 Task.Run(() => LogAsync(...))），不阻塞主线程

采样中间件实现

public class SamplingLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;
    private readonly Random _rng = new();

    public SamplingLoggingMiddleware(RequestDelegate next, ILogger logger) 
        => (_next, _logger) = (next, logger);

    public async Task InvokeAsync(HttpContext context)
    {
        // 每请求独立采样：5% 概率记录完整日志
        bool shouldLog = _rng.NextDouble() < 0.05;
        if (shouldLog)
            _logger.LogInformation("REQ: {Method} {Path}", context.Request.Method, context.Request.Path);

        await _next(context); // 非阻塞：日志已异步触发
    }
}

逻辑分析：_rng.NextDouble() < 0.05 实现均匀概率采样；LogInformation 内部使用 ILogger<T> 的异步适配器，实际落盘由日志提供程序后台线程完成；await _next(context) 保证中间件链继续执行，不等待日志写入。

采样策略对比

策略	CPU 开销	内存压力	时序保真度
全量同步日志	高	低	高
概率采样 + 异步	极低	中	中
基于 QPS 动态调频	中	低	高

graph TD
    A[HTTP 请求] --> B[SamplingLoggingMiddleware]
    B -->|采样通过| C[记录结构化日志]
    B -->|始终| D[继续 pipeline]
    C --> E[日志提供程序后台线程池]
    D --> F[业务处理]

4.2 异步 trace 上报与本地缓冲区溢出保护机制

在高吞吐场景下，同步上报 trace 数据易阻塞业务线程。因此采用异步上报 + 环形缓冲区（RingBuffer）组合策略。

缓冲区结构设计

固定容量（如 8192 条 trace 记录）
生产者（采集端）无锁写入，消费者（上报协程）单线程读取
溢出时启用采样丢弃策略：仅保留 ERROR 级 trace，WARN 及 INFO 按 10% 概率保留

关键保护逻辑（Go 实现）

func (b *RingBuffer) Write(t *Trace) bool {
    next := atomic.AddUint64(&b.tail, 1) % uint64(b.cap)
    if atomic.LoadUint64(&b.head) == next { // 缓冲区满
        return b.sampleDrop(t) // 触发分级采样
    }
    b.data[next] = t
    return true
}

b.tail 和 b.head 均为原子变量；sampleDrop() 根据 t.Level 和预设阈值动态决策是否丢弃，避免暴力截断导致关键链路丢失。

溢出策略对比

策略	保留率（INFO）	保留率（ERROR）	实时性影响
全量丢弃	0%	0%	低
FIFO 截断	~50%（均质）	~50%	中
分级采样	10%	100%	极低

graph TD
    A[采集 trace] --> B{RingBuffer 写入}
    B -->|成功| C[异步批量上报]
    B -->|满| D[分级采样判断]
    D -->|ERROR| E[强制入队]
    D -->|INFO/WARN| F[随机抽样]

4.3 跳转路径中关键环节（如签名校验、访问限流）的延迟隔离设计

为保障核心跳转链路的低延迟与高可用，需对非核心但强依赖的中间环节（如 JWT 签名校验、令牌桶限流）实施异步化 + 超时熔断 + 降级通道三重隔离。

异步校验与超时控制

// 使用 CompletableFuture 实现签名校验异步化，设定硬性超时
CompletableFuture<JwtPayload> payloadFuture = 
    CompletableFuture.supplyAsync(() -> verifyJwt(token), jwtPool)
        .orTimeout(50, TimeUnit.MILLISECONDS) // 关键：强制中断长耗时
        .exceptionally(ex -> {
            log.warn("JWT verify timeout, fallback to basic auth", ex);
            return fallbackPayload(); // 降级为轻量身份标识
        });

逻辑分析：orTimeout 避免线程阻塞，jwtPool 为专用线程池（非 Tomcat 共享池），防止签名校验拖垮整个请求线程；50ms 是基于 P99 延迟压测确定的业务容忍阈值。

限流策略分层隔离

环节	执行位置	超时阈值	降级动作
签名校验	异步线程池	50ms	返回基础用户上下文
访问限流	同步前置	5ms	拒绝并返回 429（不重试）

流量隔离流程

graph TD
    A[HTTP 请求] --> B{是否启用延迟隔离？}
    B -->|是| C[同步执行限流检查]
    B -->|否| D[直连业务逻辑]
    C --> E[≤5ms？]
    E -->|是| F[异步发起签名校验]
    E -->|否| G[立即返回 429]
    F --> H[50ms 内完成？]
    H -->|是| I[注入完整 JwtPayload]
    H -->|否| J[注入 fallbackPayload]

4.4 eBPF 辅助观测：HTTP 请求在内核协议栈中的真实驻留时长测量

传统用户态工具（如 tcpdump 或 curl -w）无法精确分离网络栈各层处理延迟。eBPF 提供零侵入、高精度的内核事件采样能力。

关键钩子点选择

tcp_recvmsg（应用层读取起点）
ip_rcv（IP 层入口）
tcp_v4_do_rcv（TCP 状态机入口）

示例：端到端时延追踪代码片段

// bpf_prog.c：记录 TCP 数据包在 ip_rcv → tcp_v4_do_rcv 的驻留时间
SEC("kprobe/ip_rcv")
int BPF_KPROBE(ip_rcv_entry, struct sk_buff *skb) {
    u64 ts = bpf_ktime_get_ns();
    bpf_map_update_elem(&start_ts_map, &skb, &ts, BPF_ANY);
    return 0;
}

逻辑分析：start_ts_map 以 skb 地址为键存储纳秒级时间戳；skb 在内核中生命周期稳定，可跨函数安全引用。BPF_ANY 确保覆盖重传等场景下的多次写入。

阶段	平均驻留时长（μs）	方差（μs²）
`ip_rcv` → `ip_local_deliver`	3.2	1.8
`tcp_v4_do_rcv` → `tcp_data_queue`	8.7	5.3

graph TD
    A[ip_rcv] --> B[ip_local_deliver]
    B --> C[tcp_v4_rcv]
    C --> D[tcp_v4_do_rcv]
    D --> E[tcp_data_queue]

第五章：从 200ms 延迟到亚毫秒跳转的工程启示

在某大型电商中台的前端重构项目中，商品详情页的路由跳转平均耗时长期稳定在 198–212ms（Lighthouse 实测，Chrome 124，DevTools Network Throttling 设为 4G）。该延迟虽未触发 Web Vitals 的“Poor”阈值（300ms），但在用户行为埋点分析中发现：跳转延迟每增加 50ms，页面停留时长下降 17%，加购转化率下降 2.3%。团队最终将首屏可交互时间（TTI）压缩至 （实测 P95 = 0.73ms），关键路径如下：

预加载与预解析解耦

放弃传统 <link rel="prefetch"> 的粗粒度资源预取，改用 IntersectionObserver + requestIdleCallback 动态触发细粒度预加载。例如，当用户滚动至“相似商品”模块可视区域前 600px 时，立即 fetch() 下一页商品卡片模板（ESM 模块，gzip 后仅 1.2KB），并调用 window.customElements.define() 提前注册组件类，规避后续 customElements.whenDefined() 的微任务排队。

路由状态零序列化开销

原架构中，Vue Router 的 beforeEach 守卫需对 to.meta 进行 JSON 序列化以写入 IndexedDB 缓存日志，单次操作平均耗时 4.2ms（V8 Profiler 数据）。重构后采用 structuredClone() 替代 JSON.stringify()，并利用 IDBObjectStore.put() 的 native structured clone 支持，将日志写入延迟压至 0.08ms；同时移除所有 to.params 的深拷贝逻辑，改用 Proxy 包裹原始对象实现惰性访问。

WebAssembly 辅助的路由决策引擎

将复杂权限校验逻辑（含 RBAC 规则树遍历、JWT claim 解析、动态策略匹配）编译为 WASM 模块（Rust → wasm32-wasi），通过 WebAssembly.instantiateStreaming() 预加载。实测对比：JS 版本校验平均 14.7ms，WASM 版本仅 0.19ms（Apple M2 Pro，启用 SIMD 优化）：

// 初始化阶段（应用启动时）
const wasmModule = await WebAssembly.instantiateStreaming(
  fetch('/auth-checker.wasm')
);

// 跳转守卫内调用（无 JS GC 停顿）
const result = wasmModule.instance.exports.check_route(
  user_id_ptr, // i32 内存地址
  route_path_ptr,
  jwt_payload_len
);

关键指标对比表

指标	重构前（2023 Q3）	重构后（2024 Q2）	变化
P95 路由跳转延迟	208 ms	0.73 ms	↓99.6%
TTI（详情页）	1240 ms	380 ms	↓69%
内存峰值（MB）	186	92	↓50%
首屏渲染帧率（FPS）	42.3	59.8	↑41%

构建时静态路由图谱生成

通过自研 Babel 插件扫描所有 router.addRoute() 调用，在构建阶段生成 Mermaid 格式路由依赖图，并注入到运行时 Router 实例：

graph LR
  A[商品详情] -->|守卫| B[权限校验]
  A -->|预加载| C[评论组件]
  B -->|成功| D[渲染主视图]
  B -->|失败| E[跳转登录页]
  C --> D

该图谱使 router.resolve() 可直接查表获取完整跳转链路，避免运行时动态解析正则路径的 O(n) 开销。实测 resolve({ name: 'ProductDetail' }) 耗时从 3.1ms 降至 0.012ms。

硬件级内存对齐优化

针对高频调用的路由参数解析函数（如 parseQuery()），使用 Rust 编写 WASM 函数并强制 16 字节内存对齐，配合 __builtin_assume_aligned() 提示编译器向量化指令生成。在 Chrome 126 中，URLSearchParams 的替代方案吞吐量达 28.4MB/s，较原生 API 提升 3.2 倍。

所有优化均通过 CI/CD 流水线中的自动化性能回归测试验证，每日执行 127 个真实设备组合（包括低端 Android Go 设备）的 Puppeteer 性能采集。