Files
xiaoyin-gateway/app/metrics.py
T
jidekin 1dc793af8e feat(logs): 视频轮询时间线落库(重启不丢)
- 新增 video_polls 表(video_id/ts/status/progress/ok/error/raw,索引 (video_id,ts))
- metrics.video_poll_push 同步落库(唯一写入点,同时保留内存态)
- _attach_polls 改为优先读库、回落内存;/logs/recent 补上 _attach_polls 调用
- 保留策略与 api_calls 共用 90 天
- 版本 2.9.7 → 2.9.8
2026-10-23 15:34:28 +08:00

362 lines
15 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""用量指标、访问日志、简单限流。
设计为无外部依赖、进程内内存态,足够网关运维排障用。
"""
from __future__ import annotations
import logging
import math
import threading
import time
from collections import deque
from contextvars import ContextVar
from typing import Any
log = logging.getLogger("api-gateway.metrics")
# 请求级「归属账号」上下文(ContextVar,每 task/请求独立;由 main.py require_auth 写入)。
# 访问日志与指标通过它给每条记录打上账号,实现:
# 普通账号只看自己名下(会话 + 自己的 API Key)产生的记录,admin 看全部。
ACCOUNT: ContextVar[str] = ContextVar("gw_account", default="anonymous")
ROLE: ContextVar[str] = ContextVar("gw_role", default="member")
# 2026-10-23 调用日志落地:请求级 rid 上下文,供 token 记账关联到具体那条日志
RID: ContextVar[str] = ContextVar("gw_rid", default="")
# M4: 按 rid 暂存请求体摘要(由 main.py 中间件写入)。AccessLog.add() 用它给每条日志
# 附上「具体请求内容」,便于在日志页查看实际发了什么。有界缓存,防无界增长。
BODY_BY_RID: dict[str, str] = {}
# ── 视频轮询历史(/logs 按 video_id 合成到「创建」那一条里,不再每个轮询各占一行) ──
VIDEO_POLLS: dict[str, "deque"] = {}
_vp_lock = threading.Lock()
_VP_MAX_VIDEOS = 200 # 同时追踪的视频任务数
_VP_MAX_POLLS = 500 # 单个任务最多保留多少条轮询
def video_poll_push(video_id: str, snap: dict) -> None:
"""记录一次视频轮询快照(内存态、有界)。"""
if not video_id:
return
with _vp_lock:
dq = VIDEO_POLLS.get(video_id)
if dq is None:
if len(VIDEO_POLLS) >= _VP_MAX_VIDEOS:
# 超上限:踢掉最老的视频任务
oldest = next(iter(VIDEO_POLLS))
VIDEO_POLLS.pop(oldest, None)
dq = deque(maxlen=_VP_MAX_POLLS)
VIDEO_POLLS[video_id] = dq
dq.append(snap)
# 2026-10-23:同时落库 —— 内存态重启即丢,库里才持久(日志页优先读库)
try:
from app import calllog as _calllog
_calllog.store.add_poll(video_id, snap)
except Exception: # noqa: BLE001
pass
def video_polls(video_id: str) -> list[dict]:
with _vp_lock:
return list(VIDEO_POLLS.get(video_id) or [])
_BODY_MAX = 2000
# ── 用量指标 ──────────────────────────────────────────
class Metrics:
"""按 模型/供应商 维度统计调用次数、token、耗时。"""
def __init__(self, enabled: bool = True, started_at: float | None = None):
self.enabled = enabled
self._lock = threading.Lock()
self.calls: dict[str, dict[str, int]] = {} # model -> {ok, fail}
self.providers: dict[str, dict[str, int]] = {} # provider -> {ok, fail}
self.tokens_prompt: int = 0
self.tokens_completion: int = 0
# 第三十四轮: token 细分 —— 上游 usage 里本来就有这两项,之前只记了总数:
# cached = prompt_tokens_details.cached_tokens(命中前缀缓存的输入量)
# reasoning = completion_tokens_details.reasoning_tokens(输出里的思考量)
self.tokens_cached: int = 0
self.tokens_reasoning: int = 0
self.latency_samples: dict[str, deque[float]] = {} # model -> 最近 N 次耗时
# 功能 11: 在途请求计数
self.in_flight: int = 0
self.in_flight_peak: int = 0
# M5+: 按账号维度的聚合(普通账号只看到自己的调用;admin 看全局)。
# 结构:account -> {"calls","providers","tokens","latency"}
self.by_account: dict[str, dict[str, Any]] = {}
# Bug 4: 热重载时保留 started_at,uptime 不因重载清零
self.started_at: float = started_at if started_at is not None else time.time()
def _acc(self, account: str) -> dict[str, Any]:
"""懒建某一账号的聚合桶(须已持 self._lock)。"""
acc = self.by_account.get(account)
if acc is None:
acc = {
"calls": {}, "providers": {},
"tokens": {"prompt": 0, "completion": 0, "cached": 0, "reasoning": 0},
"latency": {},
}
self.by_account[account] = acc
return acc
def increment_inflight(self) -> None:
"""功能 11:请求进入 +1。"""
with self._lock:
self.in_flight += 1
if self.in_flight > self.in_flight_peak:
self.in_flight_peak = self.in_flight
def decrement_inflight(self) -> None:
"""功能 11:请求结束 -1。"""
with self._lock:
self.in_flight = max(0, self.in_flight - 1)
def in_flight_snapshot(self) -> int:
with self._lock:
return self.in_flight
@staticmethod
def _bucket(d: dict, k: str) -> dict[str, int]:
return d.setdefault(k, {"ok": 0, "fail": 0})
def record_call(self, model: str, provider: str | None, ok: bool,
account: str | None = None) -> None:
"""记录一次调用结果。
account(M5+):未显式传入时取请求级 ACCOUNT 上下文;非 anonymous 时额外累加
到该账号自己的聚合桶,供「只看本人的指标」使用。
"""
if not self.enabled:
return
a = account or ACCOUNT.get()
with self._lock:
self._bucket(self.calls, model)["ok" if ok else "fail"] += 1
if provider:
self._bucket(self.providers, provider)["ok" if ok else "fail"] += 1
if a and a != "anonymous":
acc = self._acc(a)
self._bucket(acc["calls"], model)["ok" if ok else "fail"] += 1
if provider:
self._bucket(acc["providers"], provider)["ok" if ok else "fail"] += 1
def record_tokens(self, prompt: int, completion: int, account: str | None = None,
cached: int = 0, reasoning: int = 0) -> None:
"""记一次调用的 token。
第三十四轮新增 cached / reasoning 细分(默认 0,老调用点不受影响):
`cached` 是输入里命中缓存的部分(**已含在 prompt 里**,不是额外的量),
`reasoning` 是输出里的思考部分(**已含在 completion 里**)——两者都只作细分展示,
求和时不要与 prompt/completion 相加。
"""
if not self.enabled:
return
a = account or ACCOUNT.get()
with self._lock:
self.tokens_prompt += prompt
self.tokens_completion += completion
self.tokens_cached += cached
self.tokens_reasoning += reasoning
if a and a != "anonymous":
acc = self._acc(a)
acc["tokens"]["prompt"] += prompt
acc["tokens"]["completion"] += completion
acc["tokens"]["cached"] += cached
acc["tokens"]["reasoning"] += reasoning
def record_latency(self, model: str, seconds: float, account: str | None = None) -> None:
if not self.enabled:
return
a = account or ACCOUNT.get()
with self._lock:
dq = self.latency_samples.setdefault(model, deque(maxlen=200))
dq.append(seconds)
if a and a != "anonymous":
acc = self._acc(a)
adq = acc["latency"].setdefault(model, deque(maxlen=200))
adq.append(seconds)
def recent_avg_latency(self, model: str, k: int = 12) -> float | None:
"""最近 k 次调用的平均耗时(秒),用于「按速度排序」路由(第十一轮 #4)。
没有样本返回 None(冷启动时上层会退回配置里的优先级顺序)。
"""
if not self.enabled:
return None
with self._lock:
dq = self.latency_samples.get(model)
if not dq:
return None
vals = list(dq)[-k:]
return (sum(vals) / len(vals)) if vals else None
def snapshot(self, account: str | None = None) -> dict[str, Any]:
"""聚合快照。account=None 返回全局(admin / 未鉴权详情用);
account 非空则只返回该账号自己的聚合(不含全局 circuits —— 熔断是供应商级基础设施,admin 才见)。
"""
if account and account != "anonymous":
with self._lock:
acc = self.by_account.get(account)
if not acc:
return dict(uptime_seconds=round(time.time() - self.started_at, 1),
in_flight=self.in_flight, in_flight_peak=self.in_flight_peak,
calls={}, providers={},
tokens={"prompt": 0, "completion": 0, "cached": 0, "reasoning": 0},
latency={})
lat = {}
for m, dq in acc["latency"].items():
if dq:
lat[m] = _latency_summary(dq)
return {
"uptime_seconds": round(time.time() - self.started_at, 1),
"in_flight": self.in_flight,
"in_flight_peak": self.in_flight_peak,
"calls": {k: dict(v) for k, v in acc["calls"].items()},
"providers": {k: dict(v) for k, v in acc["providers"].items()},
"tokens": _tokens_out(acc["tokens"]),
"latency": lat,
}
return self._snapshot_global()
def _snapshot_global(self) -> dict[str, Any]:
# Bug 7 修复: 整个快照在锁内构造,避免并发写 dict 时迭代抛
# RuntimeError: dictionary changed size during iteration
with self._lock:
latency_out: dict[str, dict[str, float]] = {}
for m, dq in self.latency_samples.items():
if dq:
latency_out[m] = _latency_summary(dq)
return {
"uptime_seconds": round(time.time() - self.started_at, 1),
"in_flight": self.in_flight,
"in_flight_peak": self.in_flight_peak,
"calls": {k: dict(v) for k, v in self.calls.items()},
"providers": {k: dict(v) for k, v in self.providers.items()},
"tokens": {"prompt": self.tokens_prompt, "completion": self.tokens_completion,
"cached": self.tokens_cached, "reasoning": self.tokens_reasoning},
"latency": latency_out,
}
def _tokens_out(t: dict) -> dict[str, int]:
"""token 细分输出的统一形状(老桶可能缺 cached/reasoning,这里补 0)。"""
return {
"prompt": int(t.get("prompt", 0) or 0),
"completion": int(t.get("completion", 0) or 0),
"cached": int(t.get("cached", 0) or 0),
"reasoning": int(t.get("reasoning", 0) or 0),
}
def _latency_summary(dq: deque) -> dict[str, float]:
"""把某模型/账号的耗时样本汇总成 avg/p50/p95(nearest-rank)。"""
s = sorted(dq)
n = len(s)
p50 = s[min(n - 1, math.ceil(0.50 * n) - 1)]
p95 = s[min(n - 1, math.ceil(0.95 * n) - 1)]
return {"avg": round(sum(s) / n, 3), "p50": p50, "p95": p95, "count": n}
# ── 访问日志 ──────────────────────────────────────────
class AccessLog:
"""最近 N 条请求的环形日志,可经 /logs 查看。"""
def __init__(self, maxlen: int = 500):
self._max = maxlen
self._buf: deque[dict[str, Any]] = deque(maxlen=maxlen)
self._lock = threading.Lock()
def add(self, entry: dict[str, Any]) -> None:
entry["ts"] = round(time.time(), 3)
# M5+: 自动补充「归属账号」(普通账号只看到自己的日志,admin 看全部)。
entry.setdefault("account", ACCOUNT.get())
# M4: 附加请求体摘要(若有)。与 main.py 中间件按 rid 暂存的内容对应。
rid = entry.get("rid")
if rid:
snip = BODY_BY_RID.pop(rid, None)
if snip:
entry["body"] = snip
# 2026-10-23:把这次请求的 token 用量挂到日志条目上(实时页展开即可看到
# prompt/completion/cached/reasoning 与缓存命中率)。
try:
from app import calllog as _calllog
_tk = _calllog.peek_tokens(str(rid))
if _tk:
entry["tokens"] = dict(_tk)
except Exception: # noqa: BLE001
pass
with self._lock:
self._buf.append(entry)
# 调用日志落地(2026-10-23):交给 app/calllog.py —— 它与请求中间件的响应元数据
# 做双向握手(谁后到谁拼行),流式请求的条目比响应晚到也能落到库里。
try:
from app import calllog
calllog.on_access(entry)
except Exception: # noqa: BLE001
pass
def tail(self, n: int = 100) -> list[dict[str, Any]]:
with self._lock:
items = list(self._buf)
return items[-n:] if n < len(items) else items
def resize(self, maxlen: int) -> None:
"""调整环形缓冲上限(热重载用),保留已有历史条目。"""
with self._lock:
if maxlen == self._max or maxlen <= 0:
return
self._max = maxlen
self._buf = deque(self._buf, maxlen=maxlen)
# ── 简单限流(per-key 令牌桶,带 LRU 桶清理) ──────────
class RateLimiter:
"""按 key 限流(QPS)。rps=None/<=0 表示不限。
Bug 2:桶数带上限(max_buckets),超出时按最后访问顺序 LRU 淘汰,
避免长时间运行 + 多 key 导致 dict 无界增长。
"""
def __init__(self, max_buckets: int = 10000):
self._max_buckets = max_buckets
self._buckets: dict[str, list[float, float]] = {}
self._lock = threading.Lock()
def _evict_if_needed(self) -> None:
"""调用方需已持锁。超出上限时,按桶的 last-access(ts)淘汰最旧的一半。"""
if len(self._buckets) <= self._max_buckets:
return
entries = sorted(self._buckets.items(), key=lambda kv: kv[1][1]) # 按 ts 升序
for k in [kk for kk, _ in entries[: len(entries) // 2]]:
self._buckets.pop(k, None)
def allow(self, key: str | None, rps: float | None) -> bool:
if not rps or rps <= 0:
return True
if not key:
return True
now = time.monotonic()
with self._lock:
cap = rps * 2 # 桶容量
entry = self._buckets.get(key)
if entry is None:
self._evict_if_needed()
# Bug 6: 首次请求也消耗一个 token(此前存满桶直接放行,等效放宽 cap+1 突发)
self._buckets[key] = [max(0.0, cap - 1.0), now]
return True
tokens, ts = entry
tokens = min(cap, tokens + (now - ts) * rps)
entry[1] = now # 更新 last-access
if tokens >= 1.0:
entry[0] = tokens - 1.0
return True
entry[0] = tokens
return False
def size(self) -> int:
with self._lock:
return len(self._buckets)