【Go云原生架构模式白皮书】：Operator、Controller、Webhook背后共用的2种元编程模式

第一章：Go云原生架构中的元编程本质

在云原生场景下，Go语言的元编程并非依赖动态反射或运行时代码生成，而是通过编译期可验证、类型安全的机制实现结构与行为的抽象统一。其本质是利用 Go 的接口契约、泛型约束、嵌入式组合及代码生成（如 go:generate + stringer/mockgen）协同构建可扩展的控制平面能力。

接口即契约：声明式行为抽象

云原生组件（如 Operator、Service Mesh Proxy Adapter）常通过定义窄接口暴露能力，而非继承庞大基类。例如：

// 定义资源同步契约，不绑定具体实现
type Reconciler interface {
    Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)
}
// 实现该接口的结构体自动获得控制器调度能力

此设计使编译器可在构建阶段校验行为一致性，避免运行时 panic。

泛型与约束：类型安全的通用逻辑复用

Go 1.18+ 泛型支持将基础设施逻辑参数化。例如，通用健康检查适配器：

// 声明约束：T 必须实现 HealthChecker 接口且为指针类型
func NewHealthProbe[T interface{ HealthChecker }](checker *T) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if (*checker).IsHealthy() { // 编译期确保方法存在
            w.WriteHeader(http.StatusOK)
        } else {
            w.WriteHeader(http.StatusServiceUnavailable)
        }
    })
}

代码生成：补全编译期缺失的元信息

Kubernetes CRD 控制器需大量样板代码。使用 controller-gen 自动生成：

# 在项目根目录执行，基于 //+kubebuilder 注释生成 deepcopy、clientset 等
make generate

关键注释示例：

//+kubebuilder:object:root=true
//+kubebuilder:subresource:status
type DatabaseCluster struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitempty"`
    Spec              DatabaseClusterSpec   `json:"spec,omitempty"`
    Status            DatabaseClusterStatus `json:"status,omitempty"`
}

生成产物	用途说明
zz_generated.deepcopy.go	提供深拷贝实现，满足 Kubernetes API Server 序列化要求
client/clientset	支持在 Operator 中以类型安全方式访问自定义资源

元编程在此处体现为：开发者仅声明意图（接口/泛型约束/注释），工具链在编译前注入可验证、高性能的运行时支撑能力。

第二章：接口抽象与运行时多态：Controller模式的基石

2.1 接口契约设计：Client-go Informer 与 EventHandler 的解耦实践

Informer 通过 cache.SharedIndexInformer 提供事件分发能力，其核心解耦机制依赖于 cache.ResourceEventHandler 接口契约：

type ResourceEventHandler interface {
    OnAdd(obj interface{})
    OnUpdate(oldObj, newObj interface{})
    OnDelete(obj interface{})
}

该接口强制实现类仅关注业务逻辑，不感知 Informer 内部队列、Reflector 或 DeltaFIFO 细节。例如自定义 Handler：

type PodLifecycleHandler struct {
    Recorder record.EventRecorder
}

func (h *PodLifecycleHandler) OnAdd(obj interface{}) {
    pod, ok := obj.(*corev1.Pod)
    if !ok { return }
    h.Recorder.Eventf(pod, corev1.EventTypeNormal, "Added", "Pod %s created", pod.Name)
}

obj 类型为 interface{}，需运行时断言；OnAdd 不保证对象已入 store，仅表示 watch 事件到达。解耦后，Handler 可独立单元测试，无需启动 Informer。

数据同步机制

• Informer 同步本地 cache 后才触发 OnAdd/OnUpdate
• OnDelete 可能接收 DeletedFinalStateUnknown 伪对象

方法	触发时机	典型用途
OnAdd	新对象首次加入本地 cache	初始化资源状态
OnUpdate	对象版本变更（ResourceVersion）	更新缓存或触发 reconcile
OnDelete	对象从 cache 中移除	清理关联资源或记录日志

graph TD
    A[Watch API Server] --> B[DeltaFIFO]
    B --> C[Pop & Process]
    C --> D[SharedInformer]
    D --> E[EventHandler.OnAdd]
    D --> F[EventHandler.OnUpdate]
    D --> G[EventHandler.OnDelete]

2.2 运行时类型断言与泛型约束：ListWatch 机制中的动态行为注入

ListWatch 依赖 runtime.TypeAssertion 实现资源对象的运行时安全转型，同时通过泛型约束 T constrained to metav1.Object 确保编译期类型合规。

类型断言与泛型协同逻辑

func (lw *ListWatcher) Watch(ctx context.Context, options metav1.ListOptions) (watch.Interface, error) {
    obj, err := lw.ListFunc(options)
    if err != nil {
        return nil, err
    }
    // 泛型约束保障 obj 必为 T，断言仅用于 interface{} → T 安全转换
    list, ok := obj.(runtime.IsList)
    if !ok {
        return nil, fmt.Errorf("expected list, got %T", obj)
    }
    return newWatcher(list), nil
}

该断言在 ListFunc 返回 interface{} 后校验是否满足 runtime.IsList 接口；泛型约束则在调用 ListFunc[T]() 时由编译器强制 T 实现 metav1.Object，避免反射开销。

核心约束边界对比

场景	泛型约束作用	运行时断言作用
编译期	检查 T 是否实现 metav1.Object	无
运行期	无	验证 obj 是否满足 runtime.IsList

数据同步机制

graph TD
    A[Start ListWatch] --> B{ListFunc 返回 interface{}}
    B --> C[泛型约束确保 T 符合 metav1.Object]
    B --> D[TypeAssertion 检查 runtime.IsList]
    C & D --> E[构造 Watcher 并启动事件流]

2.3 方法集重载模拟：Reconcile 函数的统一入口与差异化实现

在控制器模式中，Reconcile 作为核心调度入口，需承载多类型资源的协同处理逻辑。其本质并非传统面向对象的重载，而是通过方法集动态分发实现语义重载。

数据同步机制

根据 req.NamespacedName 解析资源类型，委托至对应处理器：

func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    obj := &unstructured.Unstructured{}
    obj.SetGroupVersionKind(schema.GroupVersionKind{
        Group:   "apps", Version: "v1", Kind: "Deployment",
    })
    if err := r.Get(ctx, req.NamespacedName, obj); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    // 分发至 Deployment 专用 reconciler
    return r.deploymentReconciler.Reconcile(ctx, obj)
}

req 提供唯一标识；r.Get() 按 GVK 动态加载资源；委托链避免 switch 膨胀，提升可扩展性。

处理器注册表对比

维度	静态 switch 分支	方法集委托
新增资源类型	修改主 Reconcile	注册新 reconciler
单元测试隔离	弱（耦合于主函数）	强（接口契约清晰）

graph TD
    A[Reconcile] --> B{解析 GVK}
    B -->|Deployment| C[deploymentReconciler]
    B -->|Service| D[serviceReconciler]
    B -->|CustomResource| E[crdReconciler]

2.4 接口组合扩展：Controller Runtime 中 Manager、Reconciler、Builder 的职责编织

Controller Runtime 的核心抽象并非孤立存在，而是通过接口组合实现职责解耦与能力编织。

Manager：生命周期协调中枢

Manager 是控制器运行时的调度总线，负责启动/停止 Reconciler、注册 Scheme、管理 Cache 与 Client，并统一处理信号与健康检查。

Builder：声明式装配器

ctrl.NewControllerManagedBy(mgr).
    For(&appsv1.Deployment{}).
    Owns(&corev1.Pod{}).
    Complete(&deploymentReconciler{})

• For() 指定主资源类型（触发 Reconcile 的事件源）；
• Owns() 声明从属资源（自动监听其变更并关联至主资源 key）；
• Complete() 将 Reconciler 注入 Controller 并注册到 Manager。

职责协同关系

组件	核心职责	依赖接口
Manager	启动调度、共享 client/cache	Runnable, LeaderElector
Reconciler	实现业务逻辑（Reconcile(ctx, req)）	client.Client, logr.Logger
Builder	声明资源关系与控制器拓扑	Manager, Controller

graph TD
    A[Manager] -->|提供 Client/Cache/EventQ| B[Controller]
    B -->|委托执行| C[Reconciler]
    D[Builder] -->|配置并注入| B
    D -->|绑定资源拓扑| A

2.5 接口即协议：从 k8s.io/apimachinery/pkg/runtime.Scheme 到自定义资源序列化策略

Kubernetes 的 Scheme 是类型注册与序列化协议的中枢，它将 Go 类型、API 组版本（GVK）与编解码器绑定，实现跨版本、跨格式（JSON/YAML/Protobuf）的无损转换。

Scheme 的核心职责

• 注册资源结构体及其 GVK 映射
• 绑定 codec.Codec 实例（如 universalDeserializer）
• 提供 ConvertToVersion 实现自动版本迁移

自定义资源序列化关键步骤

scheme := runtime.NewScheme()
// 注册内置类型（如 v1.Pod）
_ = corev1.AddToScheme(scheme)
// 注册 CRD 类型（需显式 AddToScheme 或使用 SchemeBuilder）
_ = myappv1.AddToScheme(scheme) // 内部调用 scheme.AddKnownTypes(...)

此处 AddToScheme 将 myappv1.MyResource 与其 GroupVersionKind{Group: "myapp.example.com", Version: "v1", Kind: "MyResource"} 关联，并注册默认 JSON 编解码器。scheme.Recognizes(gvk) 可校验该 GVK 是否可被识别。

组件	作用	是否可扩展
Scheme	类型注册中心	✅（通过 AddKnownTypes）
UniversalDeserializer	自动推导 codec	✅（支持自定义 runtime.Codec）
ConversionHook	跨版本字段转换逻辑	✅（通过 AddFieldLabelConversionFunc）

graph TD
    A[客户端写入 MyResource v1] --> B[Scheme.LookupSchemeName → v1.MyResource]
    B --> C[Codec.Encode → JSON bytes]
    C --> D[API Server 存储 etcd]
    D --> E[读取时根据 Content-Type + Accept 头选择 Codec]
    E --> F[Decode → runtime.Object → 类型断言]

第三章：反射驱动的声明式编排：Operator核心元编程范式

3.1 reflect.Type 与 reflect.Value 在 CRD 结构体到 API Server Schema 映射中的应用

Kubernetes API Server 不直接理解 Go 结构体，需通过 reflect 动态提取字段元信息以生成 OpenAPI v3 Schema。

核心映射逻辑

• reflect.Type 提供字段名、标签（如 json:"spec,omitempty"）、嵌套层级与类型类别（struct/map/slice）
• reflect.Value 提供运行时默认值、零值判断及结构体实例的递归遍历能力

字段标签解析示例

type MyCRD struct {
    Spec MySpec `json:"spec" protobuf:"bytes,2,opt,name=spec"`
}
// reflect.TypeOf(MyCRD{}).Field(0) → 获取 json tag、protobuf tag、是否omitempty

该反射调用返回 StructField，其中 Tag.Get("json") 解析出 "spec,omitempty"，用于生成 x-kubernetes-preserve-unknown-fields: false 等 schema 约束。

类型映射对照表

Go 类型	OpenAPI Type	备注
string	string	支持 maxLength 校验
[]string	array	自动推导 items.type
*int32	integer	nullable: true

graph TD
    A[CRD Go Struct] --> B{reflect.TypeOf}
    B --> C[Field Name + JSON Tag]
    B --> D[Type Kind: Struct/Ptr/Map]
    C & D --> E[OpenAPI Schema Node]

3.2 struct tag 驱动的字段级元数据提取：+kubebuilder:xxx 注解的解析与校验实现

Kubebuilder 通过 reflect.StructTag 解析 Go 结构体字段上的 +kubebuilder: tag，将声明式注解转化为运行时可操作的元数据。

核心解析流程

// 示例结构体字段
type MyCRD struct {
  Replicas int `json:"replicas" kubebuilder:"default=1,min=0,max=100"`
}

kubebuilder tag 被 controller-tools/pkg/crd/schema.go 中的 parseTag() 提取为 TagOptions 映射，键为 default/min/max，值经 strconv 安全转换并类型校验。

支持的关键注解语义

注解名	用途	类型约束
default	设置 OpenAPI 默认值	与字段类型一致
validation	嵌入 CEL 表达式校验逻辑	字符串格式
nullable	控制字段是否允许 nil	true/false

校验执行链路

graph TD
  A[Struct Field] --> B{Has +kubebuilder: tag?}
  B -->|Yes| C[Parse key=value pairs]
  C --> D[Type-coerce values]
  D --> E[Validate against field type]
  E --> F[Generate OpenAPI v3 Schema]

校验失败时抛出 field validation error 并中断 CRD 生成，确保 API 服务器 schema 的强一致性。

3.3 动态对象构建与深度合并：unstructured.Unstructured 与 controllerutil.SetControllerReference 的反射底层逻辑

核心机制解析

unstructured.Unstructured 通过 map[string]interface{} 实现零结构依赖的资源建模，其 DeepCopyObject() 本质调用 scheme.Scheme.DeepCopy()，触发反射遍历字段并克隆嵌套 map/slice。

控制器引用注入原理

controllerutil.SetControllerReference 利用反射修改 metadata.ownerReferences 字段：

// 设置 OwnerReference 并自动填充 APIVersion/Kind
if err := controllerutil.SetControllerReference(owner, obj, scheme); err != nil {
    return err // owner 必须有 TypeMeta 和 ObjectMeta
}

参数说明：owner 需含完整 GroupVersionKind（由 scheme.LookupScheme() 反射推导）；obj 必须为 *unstructured.Unstructured 或 runtime.Object；scheme 提供类型注册元信息，驱动 runtime.DefaultUnstructuredConverter.FromUnstructured() 的字段映射。

深度合并关键路径

阶段	反射操作	触发条件
类型识别	reflect.TypeOf().Kind()	判别 struct/map/slice
字段遍历	reflect.Value.FieldByName()	定位 OwnerReferences
值写入	reflect.Value.SetMapIndex()	向 map[string]interface{} 插入新 reference

graph TD
    A[SetControllerReference] --> B{Is owner typed?}
    B -->|Yes| C[Extract GVK via scheme]
    B -->|No| D[Fail: missing TypeMeta]
    C --> E[Reflect into obj's metadata]
    E --> F[Append to ownerReferences slice]

第四章：函数式钩子与生命周期织入：Webhook的高阶元编程实践

4.1 函数值作为配置项：AdmissionReview 处理链中 HandlerFunc 的注册与中间件编排

Kubernetes 准入控制链的核心抽象是 HandlerFunc —— 一个接受 *admissionv1.AdmissionReview 并返回 *admissionv1.AdmissionResponse 的函数类型。它天然支持函数式编排。

注册即配置

// 定义校验中间件：检查命名空间标签
func namespaceLabelCheck(next admission.Handler) admission.Handler {
    return admission.HandlerFunc(func(ctx context.Context, req *admissionv1.AdmissionRequest) *admissionv1.AdmissionResponse {
        if req.Namespace != "" && !hasRequiredLabel(req.Namespace) {
            return admission.Denied("namespace missing 'env=prod'")
        }
        return next.Handle(ctx, req)
    })
}

该函数接收 admission.Handler（可为链式下一环），返回新 Handler，实现责任链模式；req.Namespace 是 AdmissionReview 中的命名空间字段，hasRequiredLabel 为自定义校验逻辑。

中间件注册顺序表

阶段	中间件名	职责
前置	namespaceLabelCheck	标签合规性拦截
主处理	policyEnforcer	OPA 策略评估
后置	auditLogger	记录决策上下文

执行流程

graph TD
    A[AdmissionReview] --> B[namespaceLabelCheck]
    B --> C[policyEnforcer]
    C --> D[auditLogger]
    D --> E[AdmissionResponse]

4.2 闭包捕获上下文：ValidatingWebhookConfiguration 中 namespace selector 与变量绑定的实现原理

Kubernetes 的 ValidatingWebhookConfiguration 支持通过 namespaceSelector 限定 Webhook 生效范围，其匹配逻辑依赖闭包对运行时 *corev1.Namespace 对象的捕获。

闭包构建时机

当 API server 初始化 webhook 链路时，为每个配置项生成校验闭包：

// 构建 namespace 匹配闭包，捕获 config.namespaceSelector
matchFunc := func(ns *corev1.Namespace) bool {
    return selector.Matches(labels.Set(ns.Labels)) // 捕获外部 selector 实例
}

该闭包在初始化阶段绑定 selector（类型 labels.Selector），避免每次调用重复解析 selector 字符串。

变量绑定关键点

• selector 在闭包外构造完成，生命周期长于单次请求
• ns.Labels 是传入参数，不参与捕获，确保线程安全
• 匹配结果无副作用，符合纯函数约束

绑定对象	是否被捕获	说明
selector	✅	静态预编译的 label 选择器
ns 参数	❌	动态传入，每次请求不同
matchFunc 本身	✅	作为 first-class 函数复用

graph TD
    A[ValidatingWebhookConfiguration] --> B[Parse namespaceSelector]
    B --> C[Compile labels.Selector]
    C --> D[Capture selector in closure]
    D --> E[matchFunc: ns → bool]

4.3 类型安全的钩子注册表：基于 map[string]admission.Decoder 的运行时路由与泛型适配器封装

Kubernetes 准入控制链中，admission.Decoder 负责将原始 []byte 请求反序列化为具体资源类型。为支持多资源、多版本动态注册，需构建类型安全的运行时路由。

核心注册表结构

type HookRegistry struct {
    decoders map[string]admission.Decoder // key: "pods/v1", "deployments/apps/v1"
}

func (r *HookRegistry) Register(kind schema.GroupVersionKind, d admission.Decoder) {
    key := kind.GroupVersion().String() + "/" + kind.Kind
    r.decoders[key] = d
}

key 唯一标识 GVK，避免跨版本解码冲突；admission.Decoder 内置 Scheme 绑定，保障类型安全。

泛型适配器封装

func NewGenericDecoder[T runtime.Object](scheme *runtime.Scheme) admission.Decoder {
    return &genericDecoder[T]{scheme: scheme}
}

type genericDecoder[T runtime.Object] struct { scheme *runtime.Scheme }
func (d *genericDecoder[T]) Decode(obj runtime.RawExtension, into runtime.Object) error {
    return d.scheme.Convert(&obj, into, nil)
}

利用 Go 1.18+ 泛型约束 T runtime.Object，在编译期校验目标类型合法性。

特性	传统方式	泛型适配器
类型检查	运行时 panic	编译期报错
注册开销	每次 new Decoder	复用实例
扩展性	需手动实现接口	一行泛型声明

graph TD
    A[Admission Request] --> B{Route by GVK Key}
    B --> C["decoders[\"pods/v1\"]"]
    B --> D["decoders[\"ingresses/networking.k8s.io/v1\"]"]
    C --> E[Decode → Pod]
    D --> F[Decode → Ingress]

4.4 Webhook 服务启动时的 HTTP Handler 树构建：gorilla/mux 与 http.ServeMux 的元编程桥接设计

Webhook 服务需在启动时动态注册多层级路由，同时兼容标准库 http.ServeMux 的注入契约。核心在于将 gorilla/mux.Router 封装为 http.Handler，并实现路由元信息的可反射性注册。

路由桥接封装

// NewBridgeHandler 返回一个符合 http.Handler 接口的 mux.Router 实例
func NewBridgeHandler() http.Handler {
    r := mux.NewRouter()
    r.HandleFunc("/webhook/{provider}", handleWebhook).Methods("POST")
    r.Use(loggingMiddleware, recoveryMiddleware) // 中间件链式注入
    return r // 自动满足 http.Handler 接口（因 Router 实现了 ServeHTTP）
}

该代码利用 gorilla/mux.Router 对 http.Handler 的隐式实现，无需适配器包装；ServeHTTP 方法由 Router 直接提供，完成 http.ServeMux 兼容性桥接。

中间件与路由元数据对照表

组件	类型	是否参与 Handler 树构建	说明
mux.Router	主路由容器	✅ 是	持有子路由树及变量匹配逻辑
http.ServeMux	标准复用器	❌ 否（仅作入口代理）	本服务中仅用于 http.ListenAndServe 入口转发

初始化流程（mermaid）

graph TD
    A[main() 启动] --> B[NewBridgeHandler()]
    B --> C[Router 实例化]
    C --> D[路径模式注册 + 中间件链绑定]
    D --> E[返回 Handler]
    E --> F[http.ListenAndServe 使用]

第五章：两种元编程模式的融合演进与边界思考

宏系统与反射驱动的协同编译流程

在 Rust + Python 混合服务框架 PyroBridge 的真实迭代中，团队将 Rust 的声明式宏（macro_rules!）与 Python 运行时反射（inspect.signature, __annotations__）深度耦合。编译期宏负责生成类型安全的 FFI 绑定桩代码，而 Python 端通过反射动态校验参数契约。以下为关键工作流片段：

// rust/src/bridge/macros.rs —— 编译期生成跨语言接口
macro_rules! pyro_export {
    ($fn_name:ident, ($($arg:ident: $ty:ty),*), $ret:ty) => {
        #[no_mangle]
        pub extern "C" fn $fn_name(
            $($arg: *const $ty),*
        ) -> *mut std::ffi::CStr {
            // …… 调用实际逻辑并序列化错误
        }
    };
}

运行时反射补全静态约束的边界案例

当处理可选泛型参数（如 Option<Vec<T>>）时，Rust 宏无法推导嵌套泛型的运行时形态。此时 Python 侧通过 typing.get_origin() 和 typing.get_args() 动态解析类型树，并将结构化元数据回传至 Rust 的 #[cfg_attr] 条件编译块中，实现“编译期生成 + 运行时修正”的双阶段元编程。下表对比了三类典型场景的协作策略：

场景	宏主导动作	反射主导动作	协同触发机制
基础类型映射（i32 → int）	生成 c_int 转换函数	校验 isinstance(x, int)	pyro_export! 展开后注入 @typecheck 装饰器
枚举序列化	生成 #[repr(C)] 枚举体	解析 Enum.__members__ 构建名称映射表	编译后 .so 加载时调用 _init_enum_mapping()
异步方法桥接	生成 tokio::task::spawn 封装体	通过 asyncio.iscoroutinefunction 动态分发	@pyro_async 装饰器在首次调用时触发 Rust 异步上下文初始化

边界冲突的实战调试记录

2024 年 Q2 的线上事故中，某金融风控模块因 #[derive(Debug)] 宏与 Python dataclass 的 __post_init__ 反射钩子执行顺序错位，导致敏感字段未被脱敏。根本原因在于：Rust 宏在编译期插入的 Debug 实现优先于 Python 运行时对 __dict__ 的拦截。修复方案采用 Mermaid 流程图明确控制流：

flowchart LR
    A[Python 调用 pyro_exported_fn] --> B{是否首次调用？}
    B -->|是| C[触发 Rust 初始化回调]
    C --> D[注册 __post_init__ 替代钩子]
    D --> E[强制清空 Debug 输出中的敏感字段]
    B -->|否| F[直接执行原生 Rust 函数]
    F --> G[返回前经 Python 侧 final_sanitize\(\) 处理]

类型擦除与重实例化的代价权衡

在 gRPC 接口自动生成工具链中，Rust 宏统一生成 prost 兼容的 Message trait 实现，但 Python 侧需根据 google.protobuf.descriptor 动态重建 message 类。实测表明：每千次 RPC 调用中，反射重建 class 的平均耗时达 127μs，而宏预生成的硬编码类仅需 8.3μs。为此引入缓存策略——以 descriptor.full_name 为键的 LRU cache，命中率提升至 99.2%，使 P99 延迟稳定在 15ms 内。

工具链版本兼容性陷阱

pybind11 v2.12 升级至 v2.13 后，其 py::module_::add_function 的签名变更导致 Rust 宏生成的绑定代码编译失败。团队建立自动化检测矩阵，覆盖 6 个 Rust 版本 × 8 个 Python 版本 × 4 种 C++ 标准组合，并在 CI 中强制要求：所有宏模板必须通过 cargo expand 输出与 pybind11 头文件 AST 进行符号级比对，确保 PYBIND11_MODULE 宏展开结果中不出现已废弃的 py::return_value_policy::automatic_reference 字符串。

跨语言调试信息对齐实践

当 Rust 宏注入 #[track_caller] 时，Python 端需同步暴露 sys._getframe(1).f_code.co_filename。为此定制 pyo3 扩展，在 PyErr_Occurred() 触发时自动捕获 Python 栈帧，并将其注入 Rust 的 eyre::Report 中。最终在 Sentry 错误面板中呈现混合栈：上半部为 src/bridge.rs:42，下半部为 app/risk.py:187，且共享同一 trace_id。