fix(trace): URLCause 用层数上限终止，去掉不可比较的 error 比较

手写终止条件只认「长度 1 的自引用」，于是：
- 两节点环（a.Err=b / b.Err=a）⇒ 死循环，打挂当前请求的 goroutine；
- uerr.Err == err 在两侧动态类型相同且不可比较时 ⇒ panic
  （comparing uncomparable type），同样打挂当前请求。

改为唯一终止条件 maxURLCauseDepth=8：超限返回只含 Op 的替身，不返回当前层
（当前层是 *url.Error，Error() 里就是整条地址，不能为防死循环把地址漏回去）。
正常单层/双层路径逐字不变。用例：两节点环 1s 内返回、不可比较类型不 panic、
自引用仍退化成替身、超限路径无 URL 片段、上限内(8 层)仍剥到内层原因。

internal/runtime/trace/urlcause.go

@@ -35,23 +35,40 @@ import (
 //   - **非 *url.Error 原样返回**：同一个值、不加包装，可安全当作「可能剥壳、也可能
 //     什么都没做」的透传。
 //
-// 唯一的例外是 `*url.Error` 没有内层原因（Err 为 nil）或链自引用：那种错误**无法**
+// 唯一的例外是 `*url.Error` 没有内层原因（Err 为 nil）或**层数超限**：那种错误
-// 在不带地址的前提下原样返回，于是退化成只含操作名（Get/Post/parse）的替身 —— 宁可
+// **无法**在不带地址的前提下原样返回，于是退化成只含操作名（Get/Post/parse）的替身
-// 少一条原因，也不回落到原串（回落就是泄漏）。net/http 的两处构造都填了 Err，因此
+// —— 宁可少一条原因，也不回落到原串（回落就是泄漏）。net/http 的两处构造都填了
-// 这条路在真实调用中到不了。
+// Err，且叠不过两层，因此这条路在真实调用中到不了。
+//
+// 终止条件**只靠层数上限**（maxURLCauseDepth），不靠「拿两个 error 比相等」：
+//   - 比相等挡不住**多节点环**（a.Err=b / b.Err=a），那种链会一直转到栈外的调用方
+//     超时为止 —— 一个错误路径上的死循环等于打挂当前请求的 goroutine；
+//   - 接口值 `==` 在两侧动态类型相同且**不可比较**（含 slice/map 的错误实现）时
+//     **panic**（`comparing uncomparable type`），而 panic 同样打挂当前请求的
+//     goroutine。今天 13 个调用点传的都是 net/http 现场构造的可比较无环错误，因此
+//     这条路不可达；但「今天不可达」会随时间衰减，而护栏的成本只是一次计数。
+//
+// 超限时的口径：**返回只含 Op 的替身，不返回当前层**。当前层仍是 `*url.Error`，
+// 它的 Error() 里就是整条地址 —— 为防死循环而把地址带出去，正是本文件要修的病害
+// 反过来复发。诊断面只丢「更内层的原因」，status/host 由调用方的文案补齐。
 func URLCause(err error) error {
-	for {
+	for depth := 0; ; depth++ {
 		var uerr *url.Error
 		if !errors.As(err, &uerr) {
 			return err
 		}
-		if uerr.Err == nil || uerr.Err == err {
+		if uerr.Err == nil || depth >= maxURLCauseDepth {
 			return urlOpOnly(uerr.Op)
 		}
 		err = uerr.Err
 	}
 }
 
+// maxURLCauseDepth 是剥壳的层数上限，**唯一的终止条件**（见 URLCause）。取 8 的
+// 理由：真实链最多两层（`client.Do` 包一次、调用方再 `%w` 一层），8 是它的四倍余量，
+// 正常路径永远碰不到；同时小到环/超深链在微秒级就停住，不会拖住请求。
+const maxURLCauseDepth = 8
+
 // urlOpOnly 是「*url.Error 没有可用内层原因」时的替身：只留操作名，地址一个字节都不留。
 func urlOpOnly(op string) error {
 	return errors.New("url " + op + " failed")

internal/runtime/trace/urlcause_test.go

@@ -9,6 +9,10 @@ package trace
 //
 // 每条用例都是「把它改回去就变红」的形状：断言的是剥壳**之后**的错误文本，也就是
 // 调用方实际打进日志的那段字符串。
+//
+// 另一半是**终止性**：剥壳跑在错误路径上，所以它自己不许成为故障源 —— 环（自引用、
+// 两节点环）不许死循环，不可比较的动态类型不许 panic，超限时也不许把地址带出来。
+// 那几条用例用「1s 内必须返回 + recover 到的 panic 一律判红」钉住（见 urlCauseWithin）。
 
 import (
 	"context"
@@ -141,22 +145,151 @@ func TestURLCauseWithoutCauseStaysURLLess(t *testing.T) {
 	}
 }
 
-// TestURLCauseSelfReferentialChainTerminates 自引用的错误链不能让剥壳死循环。
+// urlCauseWithin 在后台调 URLCause，**1s 内没回来**就当死循环判红；期间发生的
+// panic 被 recover 成第二个返回值。两条都是「错误路径炸掉当前请求 goroutine」的
+// 形状，因此都算红 —— 而剥壳本身在真实链上只要几纳秒，1s 是一万倍的余量。
+func urlCauseWithin(t *testing.T, err error) (cause error, panicked any) {
+	t.Helper()
+	type outcome struct {
+		cause  error
+		reason any
+	}
+	done := make(chan outcome, 1)
+	go func() {
+		var out outcome
+		defer func() {
+			out.reason = recover()
+			done <- out
+		}()
+		out.cause = URLCause(err)
+	}()
+	select {
+	case out := <-done:
+		return out.cause, out.reason
+	case <-time.After(time.Second):
+		t.Fatalf("URLCause 1s 内没有返回：终止条件失效（错误路径上的死循环）")
+		return nil, nil
+	}
+}
+
+// urlCauseRedlines 是「剥壳结果里一个地址片段都不许出现」的统一断言。
+var urlCauseRedlines = []string{"https://", ".example.com", "access_token", "SECRET"}
+
+// assertURLLess 断言剥壳结果非 nil 且不含任何地址片段，并回传错误文本。
+func assertURLLess(t *testing.T, got error) string {
+	t.Helper()
+	if got == nil {
+		t.Fatal("返回了 nil")
+	}
+	msg := got.Error()
+	for _, fragment := range urlCauseRedlines {
+		if strings.Contains(msg, fragment) {
+			t.Fatalf("地址片段 %q 进了错误：%v", fragment, msg)
+		}
+	}
+	return msg
+}
+
+// TestURLCauseSelfReferentialChainTerminates 自引用链（a.Err=a）必须终止，且退化成
+// 只含操作名的替身：回到「返回当前层」或「原串」都会把地址带出来。
 func TestURLCauseSelfReferentialChainTerminates(t *testing.T) {
 	t.Parallel()
 	self := &url.Error{Op: "Post", URL: "https://h/p?access_token=SELF-SECRET"}
 	self.Err = self
-	done := make(chan error, 1)
+
-	go func() { done <- URLCause(self) }()
+	got, panicked := urlCauseWithin(t, self)
-	select {
+	if panicked != nil {
-	case got := <-done:
+		t.Fatalf("自引用链上 panic 了：%v", panicked)
-		if got == nil {
+	}
-			t.Fatal("返回了 nil")
+	if msg := assertURLLess(t, got); msg != "url Post failed" {
+		t.Fatalf("自引用链没有退化成只含 Op 的替身：%v", msg)
+	}
+}
+
+// TestURLCauseTwoNodeCycleTerminates 两节点环（a.Err=b / b.Err=a）必须终止：只认
+// 「长度 1 的自引用」的终止条件在这里会一直转下去（旧实现的形状），把当前请求的
+// goroutine 卡死。
+func TestURLCauseTwoNodeCycleTerminates(t *testing.T) {
+	t.Parallel()
+	a := &url.Error{Op: "Get", URL: "https://a.example.com/p?access_token=CYCLE-A-SECRET"}
+	b := &url.Error{Op: "Get", URL: "https://b.example.com/p?access_token=CYCLE-B-SECRET"}
+	a.Err = b
+	b.Err = a
+
+	got, panicked := urlCauseWithin(t, a)
+	if panicked != nil {
+		t.Fatalf("两节点环上 panic 了：%v", panicked)
+	}
+	msg := assertURLLess(t, got)
+	if strings.Contains(msg, "CYCLE-A-SECRET") || strings.Contains(msg, "CYCLE-B-SECRET") {
+		t.Fatalf("环上终止把地址带了出来：%v", msg)
+	}
+}
+
+// uncomparableErr 的**动态类型不可比较**（struct 值里带 slice）：接口值 `==` 拿它
+// 比较会 panic（comparing uncomparable type），而 Unwrap 指回外层 *url.Error 让整条
+// 链成环。两者合起来正是「今天的终止条件换成不可比较的 error 就 panic」的形状。
+type uncomparableErr struct {
+	parts []string
+	wrap  error
+}
+
+func (e uncomparableErr) Error() string { return strings.Join(e.parts, " ") }
+func (e uncomparableErr) Unwrap() error { return e.wrap }
+
+// TestURLCauseUncomparableDynamicTypeDoesNotPanic 不可比较的动态类型不得 panic：
+// 错误路径上的 panic 会打挂当前请求的 goroutine。改成 `uerr.Err == err` 就变红。
+func TestURLCauseUncomparableDynamicTypeDoesNotPanic(t *testing.T) {
+	t.Parallel()
+	outer := &url.Error{Op: "Post", URL: "https://api.example.com/p?access_token=UNCOMPARABLE-SECRET"}
+	outer.Err = uncomparableErr{parts: []string{"dial", "tcp", "refused"}, wrap: outer}
+
+	got, panicked := urlCauseWithin(t, outer)
+	if panicked != nil {
+		t.Fatalf("不可比较的动态类型上 panic 了（错误路径上的 panic 会打挂当前请求）：%v", panicked)
+	}
+	assertURLLess(t, got)
+}
+
+// TestURLCauseDepthCapKeepsURLLess 链深超过上限时**仍然不许**出现地址：为防死循环
+// 而退回「当前层」（*url.Error，Error() 里就是整条地址）等于把本文件要修的病害从
+// 后门放回来。超限的口径是「只含 Op 的替身」，连带把更深层的原因一起丢掉。
+func TestURLCauseDepthCapKeepsURLLess(t *testing.T) {
+	t.Parallel()
+	var chain error = errors.New("connection reset by peer")
+	for i := maxURLCauseDepth + 4; i > 0; i-- {
+		chain = &url.Error{
+			Op:  "Get",
+			URL: fmt.Sprintf("https://h%d.example.com/p?access_token=DEEP-%d-SECRET", i, i),
+			Err: chain,
 		}
-		if strings.Contains(got.Error(), "SELF-SECRET") {
+	}
-			t.Fatalf("自引用链把地址带了出来：%v", got)
+
-		}
+	got, panicked := urlCauseWithin(t, chain)
-	case <-time.After(5 * time.Second):
+	if panicked != nil {
-		t.Fatal("URLCause 在自引用链上没有终止")
+		t.Fatalf("超深链上 panic 了：%v", panicked)
+	}
+	if msg := assertURLLess(t, got); msg != "url Get failed" {
+		t.Fatalf("超限后的口径不是「只含 Op 的替身」：%v", msg)
+	}
+}
+
+// TestURLCauseStripsExactlyUpToCap 上限之内的深链仍然**逐层剥到**内层原因：护栏只
+// 收紧「超过上限」那一侧，不得顺带削掉正常路径的诊断面。
+func TestURLCauseStripsExactlyUpToCap(t *testing.T) {
+	t.Parallel()
+	inner := errors.New("i/o timeout")
+	var chain error = inner
+	for i := 0; i < maxURLCauseDepth; i++ {
+		chain = &url.Error{Op: "Get", URL: fmt.Sprintf("https://h%d.example.com/p?access_token=CAP-%d-SECRET", i, i), Err: chain}
+	}
+
+	got, panicked := urlCauseWithin(t, chain)
+	if panicked != nil {
+		t.Fatalf("上限内的深链上 panic 了：%v", panicked)
+	}
+	assertURLLess(t, got)
+	if !errors.Is(got, inner) {
+		t.Fatalf("%d 层链（正好等于上限）没有剥到内层原因：%v", maxURLCauseDepth, got)
 	}
 }