jianf/ModelRouter
1
0
Fork 0
mirror of https://gitcode.com/JianFeeeee/ModelRouter.git synced 2026-10-05 15:07:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(plugin): AUTO 调度轨迹可见（chain_step stage）

Browse Source 
被问"还有 auto 调度相关 stage 呢？"问出来的真实缺口。

## 问题
chainDrive 只返回 (resp, src, model, err)，调用方只知道**最终哪个槽位赢了**。
遍历过程中算出来又丢掉的东西——哪些档被跳过、为什么跳过、哪些槽位硬失败、
哪档全忙——一律不可见。ChainErr 里其实有这些，但**只在全部失败时**才填，
而它是 error 返回值不是记录。于是：

    "tier 1 冷却所以降级到 tier 3"  ==  "tier 1 正常接单"

对插件而言 tier 只是个常量 -2（"resolved by the chain"），信息量为零。而这
恰恰是优先级链存在的全部理由，也是"我那个贵模型为什么没被用"的答案。

## 做法（scheduler 侧零新依赖）
新增 TraceEvent / TraceSink，chainDrive 多一个可选 sink 参数：

  - TraceEvent 是本包的普通 struct，sink 是 func 参数 ⇒ **不新增 import**，
    scheduler 仍然可独立测试
  - sink 为 nil 时每次 emit 只多一次 nil 判断；没有插件的网关在 AUTO 热路径上
    零开销（gateway 的 chainTraceSink 直接返回 nil）
  - 事件是纯观测：scheduler 不基于它做任何分支，gateway 也不把它喂回路由/
    冷却/配额

四种 kind：tier_skip / slot_fail / tier_busy / selected，selected 每次成功
遍历恰好一次且是最后一步。顺序保证所有 step 在 routed 之前。

## 暴露给插件
新增 chain_step stage（逐个步骤），并在 request_end 载荷里加三个便于做报表的
字段：chain_walk（上限 12 步，防审计记录膨胀）、degraded、tier_served。

## ★ 计费口径（我按推荐的做，已写进文档，需要你确认）
**按实际服务的模型计费**：降级到 tier 3 仍按 tier 3 的价算，轨迹只作观测。
理由与 §7.5 的边界一致——插件只报表不执法，两套口径混在一起会引出"降级该不该
多收钱"这种无法从代码判断的争议。若要改成"按本该用的档计价"，需要在 models
价目里允许按 tier 定价，这我没做，因为那是个产品决策。

## 计费插件同步消费
by_tier_served / skip_reasons / degraded_reqs 三个新维度。skip_reasons 的等待
时长做了归一（`no free slot within <wait>`），否则 busy-wait 文案一变就多一行。
降级次数在 request_end 里计而不是在 chain_step 里计：一次降级的请求要走多步，
按步计会重复计数。

## 判据（346 个测试全绿，新增 15 个）
  scheduler  6 个：正常路径只发一个 selected / 跳档+降级可见 / 硬失败与跳档
                严格区分（不可混为一谈，否则抖动上游看起来像空闲上游）/
                nil sink 安全 / 全失败时轨迹与 ChainErr 并存且不互相破坏 /
                空链不发事件
  gateway    1 个端到端：tier 1 全 500 → 插件收到 slot_fail(tier 1) +
                selected(tier 2)，request_end 的 tier_served=2 且 degraded=true
  lua        2 个：降级计数与按实际模型计价 / 跳过原因归一聚合
  lua        1 个：chain_step 是真 stage 且顺序正确

3 个变异都红：去掉 slot_fail（3 个判据红）/ 去掉 tier_skip（1 个）/
去掉 degraded 字段（1 个）。
This commit is contained in:
JianFeeeee
2026-10-02 01:03:39 +08:00
parent 8c18e0c3d7
commit 42764bc99e
11 changed files with 766 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
internal/scheduler/scheduler_test.go
View File

@ -176,7 +176,7 @@ func TestChainRoundRobin(t *testing.T) {
s := New(0)
var got []string
for i := 0; i < 4; i++ {
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("iter %d: %v", i, err)
}
@ -200,7 +200,7 @@ func TestChainPreferenceSinksButStaysReachable(t *testing.T) {
{Tier: 0, Model: "g", Source: "good"},
}, bySource(neg, good))
s := New(0)
resp, src, model, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
resp, src, model, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("chain: %v", err)
}
@ -213,7 +213,7 @@ func TestChainPreferenceSinksButStaysReachable(t *testing.T) {
t.Fatal("neg was tried first and succeeded; good must not be attempted")
}
// Second request: cursor advances. neg wins again (good hard-fails).
resp2, src2, _, err2 := s.ChainChat(context.Background(), ch, chatReq(), nil)
resp2, src2, _, err2 := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err2 != nil {
t.Fatalf("second chain: %v", err2)
}
@ -230,7 +230,7 @@ func TestChainBusySkipsWithoutPenalty(t *testing.T) {
{Tier: 0, Model: "b", Source: "s2"},
}, bySource(a, b))
s := New(0)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("chain: %v", err)
}
@ -256,7 +256,7 @@ func TestChainAllBusyBoundedWaitThenNextTier(t *testing.T) {
}, bySource(a, b, c))
s := New(0)
t0 := time.Now()
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
el := time.Since(t0)
if err != nil {
t.Fatalf("chain: %v", err)
@ -277,7 +277,7 @@ func TestChainQuotaExhausted(t *testing.T) {
}, bySource(a, b))
s := New(0)
exhausted := func(sl *Slot) bool { return sl.Source == "s1" && sl.Quota > 0 }
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), exhausted)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), exhausted, nil)
if err != nil {
t.Fatalf("chain: %v", err)
}
@ -300,7 +300,7 @@ func TestChainErrSummary(t *testing.T) {
{Tier: 1, Model: "c", Source: "s3"},
}, bySource(a, b, c))
s := New(0)
_, _, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, _, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
var ce *ChainErr
if !errors.As(err, &ce) {
t.Fatalf("err = %v, want *ChainErr", err)
@ -325,7 +325,7 @@ func TestChainStreamFallsBackBeforeFirstChunk(t *testing.T) {
{Tier: 0, Model: "b", Source: "s2"},
}, bySource(a, b))
s := New(0)
chunks, src, model, err := s.ChainChatStream(context.Background(), ch, chatReq(), nil)
chunks, src, model, err := s.ChainChatStream(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("chain stream: %v", err)
}
@ -365,7 +365,7 @@ func TestChainProbeIsLastResort(t *testing.T) {
}, bySource(healthy, cooling))
s := New(0)
for i := 0; i < 3; i++ {
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("iter %d: %v", i, err)
}
@ -390,7 +390,7 @@ func TestChainProbeServesWhenNothingElseCan(t *testing.T) {
cooling.probeable.Store(true)
ch := BuildChain([]Rule{{Tier: 0, Model: "c", Source: "cooling"}}, bySource(cooling))
s := New(0)
resp, src, model, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
resp, src, model, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("probe must serve the request: %v", err)
}
@ -417,14 +417,14 @@ func TestChainProbePermitReleasedOnFailure(t *testing.T) {
cooling.fail.Store(true)
ch := BuildChain([]Rule{{Tier: 0, Model: "c", Source: "cooling"}}, bySource(cooling))
s := New(0)
if _, _, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil); err == nil {
if _, _, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil); err == nil {
t.Fatal("expected the failing probe to surface an error")
}
if cooling.probeClaims.Load() != 1 || cooling.probeDones.Load() != 1 {
t.Fatalf("permit accounting: claims=%d dones=%d, want 1/1", cooling.probeClaims.Load(), cooling.probeDones.Load())
}
// permit is free again for the next attempt
if _, _, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil); err == nil {
if _, _, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil); err == nil {
t.Fatal("expected the second probe to fail too")
}
if cooling.probeClaims.Load() != 2 {
@ -443,7 +443,7 @@ func TestChainProbeDoesNotBlockTierFallthrough(t *testing.T) {
{Tier: 2, Model: "b", Source: "backup"},
}, bySource(cold, backup))
s := New(0)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil || src != "backup" {
t.Fatalf("want fallthrough to backup, got src=%q err=%v", src, err)
}
@ -482,7 +482,7 @@ func TestChainProbeRoundRobinUnaffected(t *testing.T) {
s := New(0)
var got []string
for i := 0; i < 4; i++ {
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil)
_, src, _, err := s.ChainChat(context.Background(), ch, chatReq(), nil, nil)
if err != nil {
t.Fatalf("iter %d: %v", i, err)
}