【Go接口灰度发布实战】：基于Header路由+etcd动态配置，零停机上线新版本（含Go SDK源码）

第一章：Go接口灰度发布的核心概念与架构演进

灰度发布（Canary Release）在Go服务治理中并非简单的流量切分机制，而是融合类型抽象、契约演进与运行时动态调度的系统性实践。其本质是通过Go接口的契约稳定性，解耦实现变更与调用方依赖，使新旧版本逻辑可在同一进程内共存并受控路由。

接口即契约：Go中灰度能力的天然基础

Go语言不支持传统OOP的继承与虚函数表，却以隐式实现的接口（interface{}）为服务演进提供轻量级契约锚点。只要新旧实现均满足同一接口定义（如 type OrderService interface { Create(*Order) error }），即可在运行时按策略注入不同实现，无需修改调用方代码。

架构演进的关键阶段

• 单体硬编码阶段：所有版本逻辑混杂于同一结构体方法中，靠if-else分支控制，难以测试与回滚
• 接口工厂阶段：通过func NewOrderService(version string) OrderService返回不同实现，依赖启动时配置
• 运行时动态代理阶段：基于go:generate生成接口代理桩，结合HTTP Header或gRPC Metadata中的x-canary-version键值，在ServeHTTP或UnaryInterceptor中解析并路由至对应实例

实现一个可灰度的接口代理示例

以下代码展示如何用标准库构建无第三方依赖的灰度路由层：

// 定义业务接口（稳定契约）
type PaymentProcessor interface {
    Charge(amount float64, currency string) error
}

// 灰度路由器：根据context携带的元数据选择实现
func (r *Router) Process(ctx context.Context, amount float64, currency string) error {
    version := "v1" // 默认版本
    if v := ctx.Value("canary-version"); v != nil {
        version = v.(string)
    }
    impl, ok := r.impls[version]
    if !ok {
        return fmt.Errorf("unsupported canary version: %s", version)
    }
    return impl.Charge(amount, currency)
}

该设计将版本决策从编译期移至请求上下文，配合OpenTelemetry的propagation.HTTPTraceFormat可跨服务透传灰度标识，形成端到端可控的渐进式发布能力。

第二章：基于Header的HTTP路由灰度策略实现

2.1 HTTP中间件设计原理与Go标准库Request/Response分析

HTTP中间件本质是责任链模式的函数式实现，围绕 http.Handler 接口构建可组合的请求处理流。

核心接口契约

type Handler interface {
    ServeHTTP(http.ResponseWriter, *http.Request)
}

ResponseWriter 是写入响应的抽象接口，不立即发送，而是缓冲至 WriteHeader() 调用后触发；*http.Request 是不可变的只读结构体，其 Context() 字段承载生命周期与取消信号。

中间件典型模式

• 封装 HandlerFunc 实现链式调用
• 利用闭包捕获配置参数（如日志前缀、超时阈值）
• 在 ServeHTTP 前后插入横切逻辑（鉴权、埋点、panic 恢复）

Go标准库关键字段对比

字段	类型	作用
Request.URL.Path	string	解析后的路径（已解码）
ResponseWriter.Header()	http.Header	响应头映射（延迟写入）
Request.Context()	context.Context	支持超时、取消与值传递

graph TD
    A[Client Request] --> B[net/http.Server]
    B --> C[Handler Chain]
    C --> D[Middleware 1]
    D --> E[Middleware 2]
    E --> F[Final Handler]
    F --> G[ResponseWriter]

2.2 自定义Header解析器开发：X-Release-Version与X-Canary-Weight提取实践

在灰度发布与版本路由场景中，需从 HTTP 请求头精准提取 X-Release-Version（语义化版本标识）和 X-Canary-Weight（流量权重百分比）。

解析逻辑设计

• 优先校验 Header 存在性与格式合法性
• X-Release-Version 需兼容 v1.2.3、1.2.3-alpha 等 SemVer 变体
• X-Canary-Weight 严格限制为 0–100 整数，支持带 % 后缀（如 "20%"）

核心解析代码

public class CanaryHeaderParser {
    private static final Pattern VERSION_PATTERN = Pattern.compile("^v?\\d+\\.\\d+\\.\\d+.*$");

    public Map<String, String> parse(HttpHeaders headers) {
        Map<String, String> result = new HashMap<>();
        // 提取并校验版本
        String version = headers.getFirst("X-Release-Version");
        if (version != null && VERSION_PATTERN.matcher(version).matches()) {
            result.put("version", version);
        }
        // 提取并归一化权重
        String weight = headers.getFirst("X-Canary-Weight");
        if (weight != null) {
            int parsed = Integer.parseInt(weight.replaceAll("%$", ""));
            if (parsed >= 0 && parsed <= 100) result.put("weight", String.valueOf(parsed));
        }
        return result;
    }
}

逻辑说明：VERSION_PATTERN 宽松匹配主流 SemVer 变体；weight.replaceAll("%$", "") 容忍冗余符号；整型范围校验防止非法路由。

支持的 Header 组合示例

X-Release-Version	X-Canary-Weight	解析结果
v2.1.0-rc1	30%	{"version":"v2.1.0-rc1","weight":"30"}
1.5.0		{"version":"1.5.0","weight":"0"}

graph TD
    A[收到HTTP请求] --> B{Header存在？}
    B -->|是| C[正则校验Version]
    B -->|否| D[跳过Version]
    C --> E[范围校验Weight]
    E --> F[构建路由元数据]

2.3 路由分发器实现：支持权重分流、用户ID哈希、白名单匹配的多策略调度器

路由分发器采用策略模式解耦调度逻辑，核心支持三种并行生效的路由策略：

• 权重分流：按后端服务实例配置 weight 进行动态加权轮询
• 用户ID哈希：对 user_id 字符串执行 MurmurHash3_x64_128 取模，保障同一用户始终命中相同实例
• 白名单匹配：优先检查请求头 X-Whitelist-Key 是否存在于 Redis 白名单集合中

def dispatch(request: Request) -> str:
    if redis.sismember("whitelist", request.headers.get("X-Whitelist-Key", "")):
        return "canary-service"
    user_hash = mmh3.hash128(request.user_id, signed=False) % 100
    if user_hash < 70:  # 70% 流量固定到 stable
        return "stable-service"
    # 剩余流量按实例权重分配（如: {"svc-a": 3, "svc-b": 7}）
    return weighted_choice(services_weights)

该实现确保白名单 > 用户哈希 > 权重分流的优先级链；mmh3.hash128 提供高均匀性与低碰撞率；weighted_choice 使用蓄水池采样避免预加载开销。

策略优先级与冲突处理

策略类型	触发条件	是否可跳过	冲突时行为
白名单匹配	X-Whitelist-Key 存在	否	强制路由至灰度集群
用户ID哈希	user_id 非空	是（需显式开启）	覆盖权重分流
权重分流	其他所有情况	否	默认兜底策略

graph TD
    A[接收请求] --> B{X-Whitelist-Key in Redis?}
    B -->|是| C[路由至 canary-service]
    B -->|否| D{user_id 是否有效?}
    D -->|是| E[计算哈希 → 取模路由]
    D -->|否| F[按权重随机选择]

2.4 灰度上下文透传：从入口中间件到业务Handler的Context链路追踪构建

灰度发布依赖全链路一致的上下文传递，需在请求生命周期内无损携带 gray-version、user-id、trace-id 等关键标识。

核心透传机制

• 入口中间件（如 Gin 的 Middleware）从 HTTP Header 提取灰度标签，注入 context.Context
• 每层 Handler 通过 ctx = context.WithValue(ctx, key, value) 向下传递，避免全局变量污染

关键代码示例

// 入口中间件：解析并注入灰度上下文
func GrayContextMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        version := c.GetHeader("X-Gray-Version") // 如 "v2-canary"
        userID := c.GetHeader("X-User-ID")
        ctx := context.WithValue(c.Request.Context(), 
            GrayVersionKey, version)
        ctx = context.WithValue(ctx, UserIDKey, userID)
        c.Request = c.Request.WithContext(ctx) // ✅ 必须重赋值 Request
        c.Next()
    }
}

逻辑分析：c.Request.WithContext() 是唯一安全替换 Context 的方式；直接修改 c.Request.Context() 返回值无效。GrayVersionKey 应为私有 interface{} 类型常量，防止 key 冲突。

上下文传递验证表

组件层级	是否支持 context.Value()	是否自动继承父 Context
Gin Handler	✅	✅（由 c.Request.Context() 保证）
Goroutine 启动	❌（需显式传入 ctx）	❌
数据库调用	✅（需驱动支持 context.Context）	✅（若封装层透传）

graph TD
    A[HTTP Request] --> B[Entrypoint Middleware]
    B --> C[Router Handler]
    C --> D[Service Layer]
    D --> E[DAO/DB Call]
    B -.->|ctx.WithValue| C
    C -.->|ctx passed in args| D
    D -.->|ctx passed to db.QueryContext| E

2.5 单元测试与集成验证：使用httptest模拟多版本Header请求并断言路由准确性

模拟多版本API请求

Go 标准库 net/http/httptest 可精准构造含 Accept-Version 或 X-API-Version 头的请求，覆盖 v1/v2 路由分支。

req := httptest.NewRequest("GET", "/users", nil)
req.Header.Set("X-API-Version", "2.0")
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)

req.Header.Set() 注入版本标识；httptest.NewRecorder() 捕获响应状态与Body；ServeHTTP 触发实际路由逻辑，不依赖网络。

断言路由准确性

需验证：

• 状态码是否匹配预期（如 v2 返回 200 OK，v1 返回 301 Moved Permanently）
• 响应头中 Content-Type 是否为 application/json; version=2.0
• JSON Body 字段结构是否符合对应版本契约

版本	路径	状态码	Content-Type
1.0	/users	301	text/plain
2.0	/users	200	application/json; version=2.0

验证流程图

graph TD
  A[构造带Version Header的Request] --> B[执行ServeHTTP]
  B --> C{检查Status Code}
  C -->|200| D[验证JSON Schema]
  C -->|301| E[验证Location Header]

第三章：etcd驱动的动态配置中心集成

3.1 etcd v3 API核心机制解析：Watch监听、Key TTL与Revision一致性保障

Watch监听：事件驱动的实时同步

etcd v3 的 Watch 基于 gRPC streaming，支持历史 Revision 回溯与断连续播：

# 监听 /config/ 开头的所有变更，从当前最新 revision 开始
etcdctl watch --rev=12345 "/config/*"

--rev 指定起始 Revision，避免事件丢失；通配符 * 由服务端匹配（非客户端过滤），降低网络开销。

Key TTL：租约（Lease）抽象分离

TTL 不再绑定 key，而是通过 Lease ID 关联：

# 创建 10s 租约，并将 key 绑定到该租约
LEASE_ID=$(etcdctl lease grant 10 | awk '{print $2}')
etcdctl put --lease=$LEASE_ID "/session/node1" "alive"

租约可被续约、撤销，多个 key 可共享同一 Lease，实现会话级生命周期管理。

Revision一致性保障

etcd 使用全局单调递增的 Logical Revision（非时间戳），保证线性一致性读写：

Revision 类型	作用域	示例值
header.revision	集群全局事务序号	12345
kv.mod_revision	单 key 最后修改序号	12340

graph TD
    A[Client Write] --> B[Leader Append to WAL]
    B --> C[Apply to Raft Log & KV Store]
    C --> D[Increment Global Revision]
    D --> E[Return header.revision=12345]

3.2 Go etcd客户端（go.etcd.io/etcd/client/v3）配置监听器封装与热重载实现

核心监听封装结构

采用 clientv3.Watch 接口构建长连接监听器，支持前缀匹配与事件过滤：

watchChan := client.Watch(ctx, "/config/", clientv3.WithPrefix(), clientv3.WithPrevKV())
for resp := range watchChan {
    for _, ev := range resp.Events {
        handleConfigUpdate(ev.Kv.Key, ev.Kv.Value, ev.Type)
    }
}

逻辑分析：WithPrefix() 实现目录级监听；WithPrevKV() 携带旧值，便于对比变更；ev.Type 区分 PUT/DELETE 事件，支撑幂等更新。

热重载关键保障机制

• ✅ 原子性：使用 sync.RWMutex 保护配置快照读写
• ✅ 一致性：监听回调中先校验 resp.Header.Revision 防止事件乱序
• ✅ 可观测性：暴露 watch_errors_total Prometheus 计数器

组件	作用
WatchChan	流式接收 etcd 事件
ConfigStore	线程安全的运行时配置容器
ReloadHook	用户自定义重载后钩子

graph TD
    A[etcd Watch] -->|事件流| B{事件类型}
    B -->|PUT| C[解析KV → 更新内存]
    B -->|DELETE| D[触发默认回退]
    C --> E[执行ReloadHook]
    D --> E

3.3 灰度规则Schema设计与校验：YAML/JSON Schema定义+运行时结构体绑定与合法性校验

灰度规则的可靠性始于可验证的契约——Schema 是声明式约束的核心载体。

YAML Schema 示例（基于 JSON Schema Draft 2020-12）

# grayrule.schema.yaml
type: object
required: [version, strategy, targets]
properties:
  version: { type: string, pattern: "^v\\d+\\.\\d+$" }
  strategy: { enum: ["canary", "percentage", "header"] }
  targets:
    type: array
    items:
      type: object
      required: [service, weight]
      properties:
        service: { type: string }
        weight: { type: integer, minimum: 0, maximum: 100 }

该 Schema 明确定义了灰度策略的拓扑结构、字段必选性及取值边界，为解析器提供静态校验依据。

运行时结构体绑定（Go）

type GrayRule struct {
    Version  string     `json:"version" validate:"regexp=^v\\d+\\.\\d+$"`
    Strategy string     `json:"strategy" validate:"oneof=canary percentage header"`
    Targets  []Target   `json:"targets" validate:"dive"`
}
type Target struct {
    Service string `json:"service"`
    Weight  int    `json:"weight" validate:"min=0,max=100"`
}

通过结构体标签实现字段级语义映射与动态校验，兼顾可读性与执行效率。

校验阶段	输入源	工具链	输出
静态校验	YAML/JSON 文件	spectral, kubernetes-schemas	Schema 兼容性报告
动态校验	解析后 Go 结构体	go-playground/validator	字段级错误定位

graph TD
  A[用户提交灰度规则] --> B{YAML/JSON 格式校验}
  B -->|通过| C[反序列化为结构体]
  B -->|失败| D[返回语法错误]
  C --> E[结构体标签校验]
  E -->|通过| F[注入路由引擎]
  E -->|失败| G[返回业务逻辑错误]

第四章：零停机上线的生产级服务编排体系

4.1 双注册双发现模式：新旧版本服务实例在etcd中独立注册与健康探针差异化配置

在灰度升级场景下，v2.3（旧）与v3.0（新）服务实例需共存于同一 etcd 集群，但注册路径与健康检测策略必须隔离。

注册路径分离

# v2.3 实例注册路径（兼容旧客户端）
key: /services/user-service/v2.3/instance-001
value: '{"ip":"10.0.1.10","port":8080,"version":"v2.3"}'

# v3.0 实例注册路径（启用新元数据结构）
key: /services/user-service/v3.0/instance-002
value: '{"ip":"10.0.2.15","port":9090,"version":"v3.0","features":["grpc-streaming"]}'

→ 路径前缀 /v2.3/ 与 /v3.0/ 实现命名空间级隔离，避免服务发现时跨版本误摘。

健康探针差异配置

版本	探针路径	超时	重试	语义含义
v2.3	/health	3s	2	仅检查进程存活
v3.0	/health?deep=true	8s	1	校验依赖 DB + 缓存连通性

流量路由逻辑

graph TD
    A[服务发现客户端] --> B{读取 /services/user-service/}
    B --> C[/v2.3/ 实例列表]
    B --> D[/v3.0/ 实例列表]
    C --> E[按 legacy LB 策略路由]
    D --> F[按 feature-flag 感知路由]

4.2 平滑启停控制：基于sync.WaitGroup与context.Context的优雅关闭与就绪探针协同机制

核心协同模型

WaitGroup 跟踪活跃 goroutine，context.Context 传递取消信号，二者通过“就绪态门控”解耦启动与终止时机。

就绪探针与关闭信号协同流程

graph TD
    A[服务启动] --> B[启动goroutine并Add(1)]
    B --> C[执行初始化/健康检查]
    C --> D{就绪？}
    D -->|是| E[就绪探针返回200]
    D -->|否| C
    E --> F[接收HTTP /healthz]
    G[收到SIGTERM] --> H[调用ctx.Cancel()]
    H --> I[WaitGroup.Wait()阻塞退出]

关键代码片段

func Run(ctx context.Context, wg *sync.WaitGroup) {
    defer wg.Done()
    wg.Add(1)

    // 启动前等待就绪（如DB连接池填充、缓存预热）
    if !isReady(ctx) { // 非阻塞健康检查
        return
    }

    // 主业务循环，响应ctx.Done()
    for {
        select {
        case <-time.After(1 * time.Second):
            // 业务逻辑
        case <-ctx.Done():
            log.Info("shutting down gracefully")
            return
        }
    }
}

wg.Add(1) 必须在 go Run(...) 前调用，避免竞态；ctx.Done() 触发后立即退出循环，defer wg.Done() 确保计数器准确归零。isReady 应设计为幂等、超时可控的轻量检查。

协同状态对照表

状态	WaitGroup计数	Context是否取消	就绪探针响应
启动中（未就绪）	>0	false	503
已就绪、运行中	>0	false	200
收到关闭信号	>0	true	200（直至退出）
完全退出	0	true	不可用

4.3 版本流量快照与回滚能力：etcd历史Revision回溯+灰度规则原子性事务写入

数据同步机制

etcd 的 revision 是全局单调递增的逻辑时钟，每次写入（包括 PUT/DELETE）均触发 revision 自增。流量快照即捕获某 revision 下全量键值状态，支持按 revision 精确回溯。

原子性事务写入

灰度规则（如 canary: {version: "v2", weight: 10}）与主干配置通过 etcd Txn 一次性提交：

# etcdctl txn --interactive（示例事务）
# 预检：确保旧规则存在且 revision 匹配
IF version("routes/service-a") = "12345"
THEN PUT /routes/service-a '{"v1":80,"v2":20}' # 新灰度权重
     PUT /meta/revision/12345 '{"snapshot":"20240520-1422"}'
ELSE THROW "revision mismatch"

逻辑分析：IF...THEN...ELSE 保证灰度开关与元数据写入强一致；version() 函数校验当前 key 的 revision，避免并发覆盖；/meta/revision/12345 记录快照锚点，为回滚提供可追溯入口。

回滚执行路径

graph TD
    A[用户触发回滚至 r12345] --> B{读取 /meta/revision/12345}
    B --> C[获取快照键列表]
    C --> D[批量 GET 对应 revision 的 value]
    D --> E[txn 写入最新 revision]

能力维度	实现方式
快照粒度	按 revision 全量键空间快照
回滚延迟
事务隔离级别	线性一致性 + 串行化提交

4.4 Prometheus指标埋点与Grafana看板：灰度成功率、延迟分布、Header命中率实时监控

核心指标定义与埋点设计

在服务入口处注入三类关键指标：

• gray_success_rate_total{env="prod",version="v2",route="api/user"}
• http_request_duration_seconds_bucket{le="0.1",phase="gray"}
• header_match_count_total{name="X-Gray-Id",matched="true"}

埋点代码示例（Go）

// 初始化指标
var (
    graySuccess = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "gray_success_rate_total",
            Help: "Count of successful gray requests",
        },
        []string{"env", "version", "route"},
    )
    requestDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "Latency distribution of HTTP requests",
            Buckets: []float64{0.01, 0.05, 0.1, 0.25, 0.5, 1.0},
        },
        []string{"phase"},
    )
    headerMatch = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "header_match_count_total",
            Help: "Header matching events",
        },
        []string{"name", "matched"},
    )
)

// 在HTTP中间件中调用
if isGrayRequest(r) {
    graySuccess.WithLabelValues("prod", "v2", "/api/user").Inc()
    requestDuration.WithLabelValues("gray").Observe(latency.Seconds())
    headerMatch.WithLabelValues("X-Gray-Id", strconv.FormatBool(hasGrayHeader)).Inc()
}

逻辑分析：

• CounterVec 支持多维标签聚合，便于按灰度版本、路由路径切片分析；
• HistogramVec 自动划分延迟桶（le 标签），配合 rate() 和 histogram_quantile() 实现 P90/P99 延迟计算；
• matched 标签布尔化，使 Header 命中率可直接通过 sum by(name)(header_match_count_total{matched="true"}) / sum(header_match_count_total) 计算。

Grafana 看板关键面板配置

面板名称	PromQL 表达式
灰度成功率（30m）	rate(gray_success_rate_total{phase="gray"}[30m]) / rate(http_requests_total{phase="gray"}[30m])
P95 延迟（灰度）	histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket{phase="gray"}[5m])) by (le))

数据流拓扑

graph TD
    A[Service Middleware] -->|Metrics Push| B[Prometheus Scraping]
    B --> C[TSDB Storage]
    C --> D[Grafana Query]
    D --> E[灰度成功率面板]
    D --> F[延迟分布热力图]
    D --> G[Header命中率趋势线]

第五章：完整Go SDK源码开源与工程化交付

开源仓库结构与模块划分

github.com/yourorg/trace-sdk-go 采用清晰的分层设计：core/ 包含上下文传播、Span生命周期管理等基础能力；exporter/otlp/ 实现标准OTLP/gRPC与HTTP双协议导出器；instrumentation/ 下按第三方库组织子模块（如 gin/v2、gorm/v2、redis/v9），每个子模块均提供自动埋点+手动增强双模式。所有模块均通过 go.mod 显式声明最小兼容版本，例如 golang.org/x/net v0.23.0，确保跨项目依赖可重现。

CI/CD流水线配置细节

GitHub Actions 工作流定义在 .github/workflows/ci.yml 中，包含四个并行阶段：

• unit-test：运行 go test -race -coverprofile=coverage.out ./...，覆盖率阈值设为 85%，失败则阻断发布；
• lint-check：集成 golangci-lint，启用 errcheck、govet、staticcheck 等12个检查器，配置 issues-exit-code: 1 强制修复；
• cross-build：构建 linux/amd64、linux/arm64、darwin/arm64 三平台二进制及 .zip 分发包；
• doc-gen：使用 swag init --parseDependency --parseInternal 自动生成 OpenAPI 3.0 文档，推送至 gh-pages 分支。

版本发布与语义化控制

采用 git tag v1.4.2 触发 GitHub Release 流程，自动生成 CHANGELOG.md：脚本解析 git log v1.4.1..v1.4.2 --oneline --no-merges，按 feat:、fix:、chore: 前缀归类条目，并校验 PR 标题是否符合 Conventional Commits 规范。每次发布同步推送至 Go Proxy（proxy.golang.org）与私有 Nexus 仓库（nexus.yourorg.com/repository/goproxy/），支持企业内网离线拉取。

工程化交付物清单

交付项	路径	说明
SDK核心包	pkg/trace	提供 TracerProvider、Span、ContextInjector 等接口
配置中心适配器	adapter/configcenter/nacos	支持从 Nacos 动态加载采样率、采样策略
K8s Operator CRD	deploy/crds/trace.yourorg.com_traceservices.yaml	定义 TraceService 自定义资源，支持声明式启停采集
性能压测报告	benchmark/report-20240521.pdf	基于 go-benchmarks 在 32核/64GB 环境下实测：10K QPS 下 Span 创建耗时 ≤12μs

flowchart LR
    A[开发者调用 sdk.StartSpan] --> B{是否启用动态配置？}
    B -->|是| C[Nacos Config Watcher]
    B -->|否| D[本地 YAML 加载]
    C --> E[实时更新采样率]
    D --> F[初始化 TracerProvider]
    E --> F
    F --> G[注入 HTTP Header]
    G --> H[OTLP Exporter 批量发送]

生产环境灰度验证机制

在 Kubernetes 集群中部署 trace-sdk-go 的灰度版本时，通过 Istio VirtualService 设置 5% 流量路由至 sdk-v1.4.2-canary Deployment，并在 otel-collector 中配置 Processor 过滤 service.name == 'payment-service' && sdk.version == 'v1.4.2' 的 Span 数据，写入独立 Kafka Topic otel-trace-canary，供 Prometheus + Grafana 实时比对错误率、P99 延迟等指标差异。

开源合规性保障措施

所有第三方依赖均通过 go list -json -m all 提取 SPDX License ID，生成 THIRD_PARTY_LICENSES.md；使用 syft 扫描 ./bin/trace-sdk-cli 二进制文件，输出 SBOM（Software Bill of Materials）JSON 清单；CI 步骤中嵌入 license-checker 工具，拒绝 AGPL-3.0 或 SSPL 等高风险许可证依赖进入主干分支。