Merge branch 'feat/m48-urlcauseharden-urlcause-depth-cap-an' into dev
This commit is contained in:
AskaEth committed
commit
4e9cd17fbd
4 files changed
+210
-24
No files matched your search
@@ -40,9 +40,10 @@ func upstreamLabel(name, baseURL string) string {
|
||||
// 而这类 error 会被 `chat run` / `loop step` 打日志。截断到 512 字节只是把
|
||||
// 「整段泄漏」变成「前 512 字节泄漏」，不是修复。
|
||||
//
|
||||
// error.code 也要过令牌守卫（trace.ErrorToken）：它在主流上游是枚举，但网关、代理与
|
||||
// 兼容层可以往里面塞任何东西 —— 包括回显的输入。不像令牌的 code 一律变空串，代价只是
|
||||
// 少一条分类提示；status / body 摘要等诊断面不受影响。
|
||||
// error.code 与 error.type 也要过令牌守卫（trace.ErrorToken）：它们在主流上游是枚举，
|
||||
// 但网关、代理与兼容层可以往里面塞任何东西 —— 包括回显的输入。不像令牌的字段一律变空
|
||||
// 串，代价只是少一条分类提示；status / body 摘要等诊断面不受影响。两个字段用同一道
|
||||
// 守卫（不按字段分别处理），是因为「同一份上游报文，两个出口口径不一致」正是下发漏点。
|
||||
//
|
||||
// 双 %w：既保持 errors.Is(err, ErrUpstream)（降级链按它分类，主 → 备 → 本地），
|
||||
// 也让 errors.Is(err, trace.ErrUpstream) 成立（调用方按上游失败分类）。
|
||||
@@ -55,6 +56,7 @@ func providerUpstreamError(name, baseURL string, resp *http.Response) error {
|
||||
return fmt.Errorf("model: %w: status %d", ErrUpstream, resp.StatusCode)
|
||||
}
|
||||
info.Code = trace.ErrorToken(info.Code)
|
||||
info.Type = trace.ErrorToken(info.Type)
|
||||
return fmt.Errorf("model: %w: %w", ErrUpstream, info)
|
||||
}
|
||||
|
||||
|
||||
@@ -2,9 +2,10 @@ package model
|
||||
|
||||
// 本文件钉住 providerUpstreamError 的两条出镜边界：
|
||||
//
|
||||
// - **error.code 是自由文本面**：它在主流上游是枚举，但网关、代理与兼容层可以往
|
||||
// 里面塞任何东西（包括回显的输入）。只有像令牌才出镜，其余变空串 —— 而 status /
|
||||
// type / 体积摘要这些诊断面不受影响。
|
||||
// - **error.code / error.type 是自由文本面**：它们在主流上游是枚举，但网关、代理与
|
||||
// 兼容层可以往里面塞任何东西（包括回显的输入）。只有像令牌才出镜，其余变空串 ——
|
||||
// 而 status / 体积摘要这些诊断面不受影响。两个字段必须同一道守卫：同一份上游报文
|
||||
// 的两个出口（本文件与 streamEventError）口径不一致，就是一个漏点。
|
||||
// - **响应体正文一个字节都不进错误**：这是 providerUpstreamError 存在的理由
|
||||
// （旧实现把体截到 512B 拼进 error，而 `chat run` / `loop step` 会把它落日志）。
|
||||
//
|
||||
@@ -92,3 +93,36 @@ func TestProviderUpstreamErrorDropsBodyText(t *testing.T) {
|
||||
t.Fatalf("error.message 的回显进了错误：%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestProviderUpstreamErrorDropsFreeTextType type 里是带空格标点的散文（网关 / 兼容层
|
||||
// 把回显塞进 type 是真实写法）⇒ 该字段整体消失（连 ` type=` 这个键都不出现），而同一
|
||||
// 份报文里的 status / code / body_bytes 仍在。去掉 type 的令牌守卫就变红 —— 兄弟出口
|
||||
// streamEventError 守的正是 type，两个出口对同一份上游报文必须口径一致。
|
||||
func TestProviderUpstreamErrorDropsFreeTextType(t *testing.T) {
|
||||
t.Parallel()
|
||||
const prose = "Invalid value: 她刚才说的那句话"
|
||||
body := `{"error":{"code":"invalid_request_error","type":"` + prose + `"}}`
|
||||
|
||||
err := providerUpstreamError("openai", "https://api.example.com/v1/chat/completions",
|
||||
upstreamErrResp(http.StatusBadRequest, body))
|
||||
if err == nil {
|
||||
t.Fatal("非 2xx 却报成功")
|
||||
}
|
||||
msg := err.Error()
|
||||
if strings.Contains(msg, prose) {
|
||||
t.Fatalf("type 里的回显进了错误（会随 chat run 落日志）：%v", msg)
|
||||
}
|
||||
// ` type=` 带前导空格：content_type= 的尾巴里也有 "type="，不能用裸子串判。
|
||||
if strings.Contains(msg, " type=") {
|
||||
t.Fatalf("非令牌形状的 type 没有被丢弃：%v", msg)
|
||||
}
|
||||
// 诊断面不能一起丢：状态、令牌形状的 code、体积摘要都还在。
|
||||
for _, want := range []string{"status=400", "code=invalid_request_error", "body_bytes=", "api.example.com"} {
|
||||
if !strings.Contains(msg, want) {
|
||||
t.Fatalf("错误里缺少 %q（诊断面不能一起丢）：%v", want, msg)
|
||||
}
|
||||
}
|
||||
if !errors.Is(err, ErrUpstream) || !errors.Is(err, trace.ErrUpstream) {
|
||||
t.Fatalf("降级链的哨兵断了：%v", err)
|
||||
}
|
||||
}
|
||||
@@ -35,23 +35,40 @@ import (
|
||||
// - **非 *url.Error 原样返回**：同一个值、不加包装，可安全当作「可能剥壳、也可能
|
||||
// 什么都没做」的透传。
|
||||
//
|
||||
// 唯一的例外是 `*url.Error` 没有内层原因（Err 为 nil）或链自引用：那种错误**无法**
|
||||
// 在不带地址的前提下原样返回，于是退化成只含操作名（Get/Post/parse）的替身 —— 宁可
|
||||
// 少一条原因，也不回落到原串（回落就是泄漏）。net/http 的两处构造都填了 Err，因此
|
||||
// 这条路在真实调用中到不了。
|
||||
// 唯一的例外是 `*url.Error` 没有内层原因（Err 为 nil）或**层数超限**：那种错误
|
||||
// **无法**在不带地址的前提下原样返回，于是退化成只含操作名（Get/Post/parse）的替身
|
||||
// —— 宁可少一条原因，也不回落到原串（回落就是泄漏）。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")
|
||||
|
||||
@@ -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) }()
|
||||
select {
|
||||
case got := <-done:
|
||||
if got == nil {
|
||||
t.Fatal("返回了 nil")
|
||||
|
||||
got, panicked := urlCauseWithin(t, self)
|
||||
if panicked != nil {
|
||||
t.Fatalf("自引用链上 panic 了：%v", panicked)
|
||||
}
|
||||
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)
|
||||
}
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("URLCause 在自引用链上没有终止")
|
||||
}
|
||||
|
||||
got, panicked := urlCauseWithin(t, chain)
|
||||
if panicked != nil {
|
||||
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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user