fix(logs,tasks): 异常日志补类名，签到失败改指数退避

- 新增 error_text：裸 TimeoutError/ConnectError 的 str 为空，原日志只剩
  「quota probe failed for cred_x: 」，额度探测 89/91 条、动态模型拉取
  54/58 条无法定位；统一输出「类名: 消息」。
- 签到连续失败按 10m→20m→40m→1h 退避，成功清零、跨天清理；管理台手动
  运行绕过退避。修两个号每 10 分钟空锤一整天、145 条 WARNING 的噪声。

Author: RobbsLuo

src/error_text.py

@@ -0,0 +1,25 @@
+"""异常 → 一行日志/展示文本。
+
+`str(error)` 对部分异常为空（`TimeoutError`、某些 `httpx.ConnectError`），
+直接 `"%s" % error` 会打出「quota probe failed for cred_x: 」这种无因日志
+（2026-11 实测 89/91 条额度探测失败、54/58 条动态模型拉取失败都是空原因），
+排障时只能看到「失败了」却不知道是超时、DNS 还是协议错误。
+
+统一带上异常类名，保证至少能区分大类；有消息时保留消息（压缩空白、限长）。
+"""
+
+from __future__ import annotations
+
+import re
+
+_WHITESPACE = re.compile(r"\s+")
+
+
+def error_text(error: BaseException, *, limit: int = 200) -> str:
+    """异常 → `类名: 消息`；消息为空时只有类名（如 `TimeoutError`）。"""
+    message = _WHITESPACE.sub(" ", str(error)).strip()
+    if not message:
+        return type(error).__name__
+    if len(message) > limit:
+        message = message[:limit] + "…"
+    return f"{type(error).__name__}: {message}"

src/provider/codebuddy/client.py

@@ -26,6 +26,7 @@
 
 from ...engine.affinity import resolve_explicit
 from ...engine.sse import iter_frames
+from ...error_text import error_text
 from ...provider import base
 from ...provider.base import ErrKind, Event, GrowthResult, Model, Quota
 from ...tasks.pacer import paced
@@ -862,7 +863,8 @@ async def list_models(self, credential_data: dict) -> list[Model]:
         except Exception as error:  # noqa: BLE001 - 兜底不是静默：错误会带上抛路径
             import logging
 
-            logging.getLogger(__name__).warning("动态模型拉取失败，回退静态表: %s", error)
+            logging.getLogger(__name__).warning("动态模型拉取失败，回退静态表: %s",
+                                                error_text(error))
             return [Model(id=mid) for mid in DEFAULT_MODELS]
 
     async def stream_chat(self, credential_data: dict, payload: dict,

src/provider/trae/client.py

@@ -16,6 +16,7 @@
 import httpx
 
 from ...engine.sse import iter_frames
+from ...error_text import error_text
 from ...provider import base
 from ...provider.base import (
     AuthFlow,
@@ -696,7 +697,7 @@ async def list_models(self, credential_data: dict) -> list[Model]:
 
                 self._dynamic_models_blocked_until = time.monotonic() + 300
                 logging.getLogger(__name__).warning(
-                    "TRAE 动态模型拉取失败，回退静态表 5 分钟: %s", error)
+                    "TRAE 动态模型拉取失败，回退静态表 5 分钟: %s", error_text(error))
         # 静态表：重名时 id 用实测大小写，元数据优先取动态结果，
         # 其次取上次成功的动态拉取（负缓存期倍率不丢）
         merged: list[Model] = []

src/tasks/checkin.py

@@ -12,6 +12,7 @@
 from ..config import live
 from ..db.crypto import CredentialDecryptError
 from ..db.repo import CredentialRepository
+from ..error_text import error_text
 from ..request_context import credential_scope
 from . import TaskReport
 from .pacer import Pacer
@@ -24,6 +25,13 @@
 # 与 `engine/limits.day_start`、`tasks/activity` 同一口径。
 _CN_TZ = ZoneInfo("Asia/Shanghai")
 
+#: 失败重试退避：首轮失败后 10 分钟再试，连续失败翻倍，封顶 1 小时。
+#: 上游对「今日积分尚未发放」会一直回同一句（实测 2026-11-05 两个号从 00:29
+#: 到 17:54 每 10 分钟锤一次 → 145 条 WARNING + 几千次无效上游调用）。
+#: 退避后一天最多 ~7 次/账号，仍能在当天补签；`trigger="manual"` 不受限制。
+_FAIL_BACKOFF_BASE = 10 * 60
+_FAIL_BACKOFF_MAX = 60 * 60
+
 
 def _cn_now(now: int | None = None) -> time.struct_time:
     """当前时刻的北京时间 struct_time（测试可注入 epoch 秒）。
@@ -101,6 +109,9 @@ def __init__(self, credentials: CredentialRepository, providers: dict,
         # 注意与下面的「时点放行」是两套键：这里是每个凭证/G 作用域的封账，
         # 那边是「今天这个时点已经触发过一轮」，语义不能合并。
         self._done_scopes: dict[str, int] = {}
+        # done_key → (连续失败次数, 下次允许重试的 epoch 秒)。失败退避，成功清零；
+        # 与 `_done_scopes` 同键同生命周期，跨天 prune 时一起清。
+        self._failures: dict[str, tuple[int, int]] = {}
         # 时点放行：键固定为「本地日期 + 时点分钟数」，抖动只改窗口、不改归属，
         # 所以执行时刻落在窗口里哪个分钟都不会让同一时点跑两次。
         self._slot_offsets: dict[str, int] = {}   # 当日该时点抽到的抖动偏移（分钟）
@@ -178,26 +189,52 @@ def _prune(self, now: time.struct_time) -> None:
         """丢掉非当天的封账记录：done_key 以日期开头，跨天后不可能再命中，
         长驻进程否则每天每账号各攒一条（无上限）。"""
         day = self._day_key(now)
-        stale = [key for key in self._done_scopes if not key.startswith(f"{day}:")]
+        prefix = f"{day}:"
+        stale = [key for key in self._done_scopes if not key.startswith(prefix)]
         for key in stale:
             del self._done_scopes[key]
+        for key in [key for key in self._failures if not key.startswith(prefix)]:
+            del self._failures[key]
 
     def _sealed(self, done_key: str, now: time.struct_time) -> bool:
         """该作用域是否已封账且封账未到期。"""
         until = self._done_scopes.get(done_key)
         return until is not None and until > _cn_epoch(now)
 
+    def _backed_off(self, done_key: str, now: time.struct_time,
+                    *, manual: bool) -> bool:
+        """失败退避未到期 → 本轮跳过；管理台「立即运行」不受退避限制。"""
+        if manual:
+            return False
+        state = self._failures.get(done_key)
+        return state is not None and state[1] > _cn_epoch(now)
+
+    def _note_failure(self, done_key: str, now: time.struct_time) -> None:
+        """记一次失败并按连续失败次数翻倍退避（10m → 20m → 40m → 封顶 1h）。"""
+        streak = self._failures.get(done_key, (0, 0))[0] + 1
+        delay = min(_FAIL_BACKOFF_BASE * 2 ** min(streak - 1, 6), _FAIL_BACKOFF_MAX)
+        self._failures[done_key] = (streak, _cn_epoch(now) + delay)
+
+    def _clear_failure(self, done_key: str) -> None:
+        """成功即清零：下次再失败从 10 分钟重新起算，不继承旧的退避档位。"""
+        self._failures.pop(done_key, None)
+
     async def run_once(self, *, now: time.struct_time | int | None = None,
                        trigger: str = "auto") -> TaskReport:
         """签到一轮：已成功（当日封账）的作用域直接跳过；失败的留到下轮重试。
 
-        `trigger` 只进审计日志（auto=定时 / manual=管理台「立即运行」），不参与
-        任何判定。
+        失败按连续次数做指数退避（10m → 20m → 40m → 封顶 1h），避免上游
+        一直回「积分尚未发放」时每 10 分钟空锤一次；`trigger="manual"`
+        （管理台立即运行）绕过退避。失败不封账，成功才封账。
+
+        `trigger` 只进审计日志（auto=定时 / manual=管理台「立即运行」），
+        除绕过失败退避外不参与任何判定。
         """
         current = now if isinstance(now, time.struct_time) else _cn_now(now)
         day = self._day_key(current)
         report = TaskReport()
         seen: set[str] = set()
+        manual = trigger == "manual"
         self._prune(current)
         for candidate in self._credentials.candidates():
             # `enabled=0`（用户软暂停）同样跳过，口径与调度器 is_selectable 一致。
@@ -232,6 +269,9 @@ async def run_once(self, *, now: time.struct_time | int | None = None,
                 report.skipped += 1                      # 同一轮同上游账号只签一次
                 continue
             seen.add(scope)
+            if self._backed_off(done_key, current, manual=manual):
+                report.skipped += 1                      # 退避未到期，不调上游
+                continue
             report.attempted += 1
             # 签到一轮含 status+claim+回查三次上游调用，与 quota_probe/growth
             # 共用同一 Pacer，避免绕开全局频率风控对策
@@ -241,11 +281,14 @@ async def run_once(self, *, now: time.struct_time | int | None = None,
                 with credential_scope(candidate.credential_id):
                     result = await provider.checkin(data)
             except Exception as error:  # noqa: BLE001
-                logger.warning("checkin failed for %s: %s", candidate.credential_id, error)
+                logger.warning("checkin failed for %s: %s", candidate.credential_id,
+                               error_text(error))
+                self._note_failure(done_key, current)
                 report.failed += 1
                 continue
             if result.ok:
                 report.succeeded += 1
+                self._clear_failure(done_key)
                 # 成功即封账该作用域：封账期内不再重试，失败凭证不受影响可继续
                 # 重试。渠道给了 `seal_until` 就按它封（签到周期 ≠ 自然日，
                 # 见 `CheckinResult.seal_until`），否则封到本地当日结束。
@@ -254,6 +297,7 @@ async def run_once(self, *, now: time.struct_time | int | None = None,
                     self._on_success(candidate.credential_id)
             else:
                 report.failed += 1
+                self._note_failure(done_key, current)
                 logger.warning("checkin failed for %s: %s",
                                candidate.credential_id, result.message or "未知原因")
             # 审计日志：成功/失败/已签都记一行（上游异常没有 result 时不记）。

src/tasks/quota_probe.py

@@ -6,6 +6,7 @@
 
 from ..db.crypto import CredentialDecryptError
 from ..db.repo import CredentialRepository
+from ..error_text import error_text
 from ..provider.base import Quota
 from ..request_context import credential_scope
 from . import TaskReport
@@ -57,7 +58,8 @@ async def run_once(self, *, apply_pacing: bool = True) -> TaskReport:
                 with credential_scope(candidate.credential_id):
                     quota = await provider.probe_quota(data)
             except Exception as error:  # noqa: BLE001 - 探测失败不能中断整批
-                logger.warning("quota probe failed for %s: %s", candidate.credential_id, error)
+                logger.warning("quota probe failed for %s: %s", candidate.credential_id,
+                               error_text(error))
                 # 探测失败 → health 置 NULL（unknown），绝不当作 0 分
                 self._credentials.mark_probe_failed(candidate.credential_id)
                 report.failed += 1

tests/provider/codebuddy/test_client_models.py

@@ -146,3 +146,16 @@ def handler(_request: httpx.Request) -> httpx.Response:
 
     with pytest.raises(UpstreamProtocolViolation):
         await _client(handler).fetch_models(CodeBuddyCredential(bearer_token="t"))
+
+
+async def test_provider_list_models_log_includes_type_when_message_empty(caplog):
+    """裸 `TimeoutError` 消息为空 → 回退日志仍要带类名，不能只剩「: 」。"""
+    class _Client:
+        async def fetch_models(self, _credential):
+            raise TimeoutError()
+
+    provider = CodeBuddyProvider(client=_Client())
+    with caplog.at_level("WARNING", logger="src.provider.codebuddy.client"):
+        models = await provider.list_models({"bearer_token": "t"})
+    assert [m.id for m in models] == list(DEFAULT_MODELS)
+    assert any("TimeoutError" in record.getMessage() for record in caplog.records)

tests/provider/trae/test_client.py

@@ -550,3 +550,16 @@ def handler(_request: httpx.Request) -> httpx.Response:
     # extra_info 之后的事件都带上真实模型名
     assert usage.model == "glm-5.2-real"
     assert finish.model == "glm-5.2-real"
+
+
+async def test_provider_model_failure_log_includes_type_when_message_empty(caplog):
+    """裸 `TimeoutError` 消息为空 → 回退日志仍要带类名，不能只剩「: 」。"""
+    class _Client:
+        async def fetch_models(self, _credential):
+            raise TimeoutError()
+
+    provider = TraeProvider(client=_Client())
+    with caplog.at_level("WARNING", logger="src.provider.trae.client"):
+        models = await provider.list_models({"accessToken": "a", "uid": "u"})
+    assert [m.id for m in models] == list(STATIC_MODELS)
+    assert any("TimeoutError" in record.getMessage() for record in caplog.records)