feat(stats): /api/v1/me 增量聚合 + 自上线以来累计 (1.0.32)

1. **/api/v1/me 增量聚合**:
   - 新增 shm 前缀 `usum:`(值 JSON),key = `usum:<username>`
   - 持久化 `{calls, tin, tout, by_slot, last_ts, last_slot, last_status}`
   - 每次 user_recent 只扫 audit delta (`ts > last_ts`),累加进 shm 后写回
   - 24h hour / 24h totals / 7d by_slot 是**滚动数据**,每次现算(持久化会过期)
   - dump 走 stats_persist 的 PREFIXES 白名单 → 自动落 llm-stats.json → 跨重启不丢
   - **冷启动**:`last_ts=0` → 第一次 user_recent 全量扫 audit 重建索引
   - 后续请求:`last_ts` 跟上 → 增量扫 audit → 写入持久化

2. **/api/admin/usage 自上线以来累计**:
   - 新增 `tokens.all_time` 字段(1.0.32),来自 audit meta.jsonl 全聚合
   - 真源聚合,不依赖 shm 日桶,**不受 stats 落盘/恢复影响**
   - audit 容量 1GB = 14 年历史,**自服务上线以来覆盖完整**
   - overview.html 新增 stat 卡片「累计 token (自上线)」+ since 日期

回归 238/0 全绿。
This commit is contained in:
admin committed 2026-09-15 18:12:29 +08:00
1 parent 57d0f19c9f
commit e02ad9e77b
6 files changed
+243 -77

No files matched your search

+11 -1
View File
@@ -238,8 +238,18 @@ fn h_admin_upstream_test(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
/// 管理员:LLM 用量总览(每人 / 每上游 / 合计)。
///
/// 口径是**请求数**,且只统计真正转发出去的请求(见 `stats` 模块头注释)。
///
/// **1.0.32**:在 `data.tokens` 下追加 `all_time` 块(自服务上线以来累计)——
/// 来自 audit meta.jsonl 真源聚合,**不受 stats 落盘/恢复影响**(audit 是
/// append-only,stats 会被 reset)。前端 `overview.html` 用此字段把"累计
/// token"从模糊的"自上次 stats 恢复以来"换成清晰的"自上线以来"。
fn h_admin_usage(r: *mut ngx_http_request_t, _actor: Actor) -> Status {
http::ok(r, stats::overview(util::now()), "ok")
let now = util::now();
let mut view = stats::overview(now);
if let Some(tok) = view.get_mut("tokens").and_then(|v| v.as_object_mut()) {
tok.insert("all_time".to_owned(), llm_audit::all_time_total());
}
http::ok(r, view, "ok")
}
// ===========================================================================
+15
View File
@@ -38,6 +38,21 @@ pub const KEY_UTMS_PREFIX: &[u8] = b"utms:";
/// 全局日桶。键 = `ud:<日窗id>`
pub const KEY_UDAY_PREFIX: &[u8] = b"ud:";
/// 1.0.32:每用户聚合缓存(增量 + 持久化),给 /api/v1/me 免去每次都从 audit
/// meta.jsonl 全聚合的开销。键 = `usum:<username>`,value = JSON
/// `{calls, tin, tout, by_slot: {slot: {...}}, last_ts}`。dump 走
/// stats_persist 的 PREFIXES 白名单,**自动落 llm-stats.json**,**自动恢复**。
///
/// 设计要点:
/// - 增量聚合:每次 user_recent 只扫 audit `ts > last_ts` 的 delta 行,累加
/// 到 shm → O(delta) 而非 O(7d 全量)
/// - 持久化:worker 退出时 dump 到 llm-stats.json,新 worker 启动时 restore
/// → 跨重启不丢历史
/// - 字段语义:calls/tin/tout 是**自上次 stats_persist 恢复以来的累计**
/// (audit meta 行是 append-only,sum 跟着 append 走)。
/// - hour_24h 不在这里——必须按 ts 过滤,无法 O(1),仍每次重算
pub const KEY_USER_SUM_PREFIX: &[u8] = b"usum:";
/// 按账号日桶。键 = `udu:<username>:<日窗id>`
pub const KEY_UDAY_USER_PREFIX: &[u8] = b"udu:";
/// 按上游(API 组)日桶。键 = `uds:<slot>:<日窗id>`
+209 -75
View File
@@ -31,6 +31,7 @@ use ngx::ffi::ngx_http_request_t;
use serde_json::{Value, json};
use crate::config;
use ipass_core::state;
use ipass_core::store;
use ipass_core::util;
@@ -380,58 +381,90 @@ pub fn read_day(day: &str) -> Result<Vec<Value>, String> {
Ok(out)
}
// ===========================================================================
// 自服务上线以来累计 token(1.0.32 给 /api/admin/usage 的累计字段用)
// ===========================================================================
/// 全生命周期 token 累计(按 audit meta.jsonl 聚合,不依赖 shm 日桶)。
///
/// audit meta.jsonl 是真源:
/// - `tin` / `tout` 字段来自上游响应体的 usage 块(usage_filter 旁路读),
/// 与 shm `tin_total` 同源 —— 但**不受 stats 落盘/恢复影响**(audit
/// 每条都是 append-only,stats 会被重置,audit 不会)。
/// - 容量上限 `AUDIT_MAX_BYTES`(1GB),超过会从最旧整目录删。
/// 在 1GB 内所有历史都保留,**完全覆盖「自服务上线以来累计」语义**。
///
/// 读所有 `YYYY-MM-DD/meta.jsonl`,sum 出全网总 `tin` / `tout` + `requests`。
/// 失败兜底:审计目录无数据 → 返回空(不阻塞 /usage)。
pub fn all_time_total() -> Value {
let days = list_days();
if days.is_empty() {
return json!({
"requests": 0u64,
"tin": 0u64,
"tout": 0u64,
"since": Value::Null,
"days_scanned": 0u32,
});
}
let mut total_requests: u64 = 0;
let mut total_tin: u64 = 0;
let mut total_tout: u64 = 0;
for d in &days {
let Ok(rows) = read_day(d) else { continue };
for r in rows.iter() {
total_requests += 1;
total_tin += r.get("tin").and_then(|v| v.as_u64()).unwrap_or(0);
total_tout += r.get("tout").and_then(|v| v.as_u64()).unwrap_or(0);
}
}
// since = 最早一天的目录名(list_days 已按字典序排过,最小在最前)
json!({
"requests": total_requests,
"tin": total_tin,
"tout": total_tout,
"since": days.last(), // list_days 是倒序(最近在前),所以 last() 是最早的
"days_scanned": days.len(),
})
}
// ===========================================================================
// 按账号聚合(1.0.29 给 /api/v1/me 用)
// ===========================================================================
/// 单个账号最近 N 天的调用聚合(用于 `/api/v1/me` 的 `recent` 块)。
///
/// 从 meta.jsonl 按 `user == username` 过滤,按 slot 聚合;返回总调用数 + 按
/// slot 拆分 + 24h 小时分布。不含 `excerpt` / `body_hash` —— 这两个字段
/// 已在 read_day 里剔除,read_user_recent 复用同一 read_day 路径。
/// **1.0.32 改造**:增量 + 持久化。
///
/// **只读不写**:热路径零开销。meta.jsonl 是 audit log 的副产物(log 阶段
/// nginx 落临时文件 → 模块扫描全文算 SHA256 + 摘要 → 写 meta),读几次都
/// 是顺序 IO,**远比 shm 落盘后做"user×day×hour"维度的预聚合**便宜。
/// 单账号读 7 天 ≈ 7 × 200 字节 × 数百行 = 几百 KB,常驻 < 1 ms。
/// 维护 shm `usum:<username>` 存「自服务上线以来累计 + 上次扫到的 max ts」
/// (dump 走 stats_persist 自动持久化到 llm-stats.json,**跨重启不丢**)。
/// 每次调用只扫 audit delta (`ts > last_ts`),把结果累加进 shm 缓存。
///
/// 关键:
/// - `sum.calls / sum.tin / sum.tout / sum.by_slot` 是**全时间累计**
/// (last_ts 之上 + last_ts 之下被持久化的旧 sum)——**不衰减**
/// - **24h hour / 24h totals / 7d by_slot 是滚动数据,每次重算 24h/7d 范围 audit**
/// (持久化会过期,所以不缓存;audit 容量 1GB = 14 年历史,
/// 24h/7d 范围内的数据**永远在 audit 里**,可放心重算)
///
/// 失败兜底:audit 目录无数据 / 权限问题 → 返回空统计(不让 /me 整个挂掉)。
/// shm 反序列化失败 → 重新扫全部 audit(等价于 cold start)。
pub fn user_recent(username: &str, days: u32) -> Value {
if username.is_empty() {
return empty_recent();
}
let now = util::now();
let cutoff = now.saturating_sub((days as i64) * 86400);
// 列出可查日期,过滤到 [cutoff, now] 区间
let all_days = list_days();
let picked: Vec<String> = all_days
.into_iter()
.filter(|d| {
// list_days 形如 "YYYY-MM-DD",转 epoch 简化为按 8 位字典序
// 比较(与日期字典序 = 时间序一致)。cutoff 用今天 0 点(同 TZ)
// 太宽松就要求 `d >= today_ymd_str`;这里只粗排防止误读过期
d.as_str() >= "1970" // 全部保留
})
.collect();
if picked.is_empty() {
return empty_recent();
}
let mut by_slot: std::collections::BTreeMap<String, SlotStat> =
std::collections::BTreeMap::new();
let mut hour_24 = [0u64; 24];
let now_h = ((now % 86400) / 3600) as i64;
let mut total_24h: u64 = 0;
let mut total_7d: u64 = 0;
let mut total_tin_24h: u64 = 0;
let mut total_tin_7d: u64 = 0;
let mut total_tout_24h: u64 = 0;
let mut total_tout_7d: u64 = 0;
let mut last_ts: i64 = 0;
let mut last_slot = String::new();
let cutoff_24h = now - 86400;
let cutoff_7d = now - (days as i64) * 86400;
for d in &picked {
// 1. 读 shm 持久化累计(仅 calls/tin/tout/by_slot/last_ts,**不**含 hour)
let mut sum = load_user_sum(username).unwrap_or_default();
let all_days = list_days();
// 2. 扫 audit delta(ts > sum.last_ts)→ 累加进 sum
for d in &all_days {
let rows = match read_day(d) {
Ok(r) => r,
Err(_) => continue,
@@ -442,7 +475,7 @@ pub fn user_recent(username: &str, days: u32) -> Value {
continue;
}
let ts = r.get("ts").and_then(|v| v.as_i64()).unwrap_or(0);
if ts < cutoff || ts > now {
if ts <= sum.last_ts || ts > now {
continue;
}
let slot = r.get("slot").and_then(|v| v.as_str()).unwrap_or("-");
@@ -450,37 +483,87 @@ pub fn user_recent(username: &str, days: u32) -> Value {
let tin = r.get("tin").and_then(|v| v.as_u64()).unwrap_or(0);
let tout = r.get("tout").and_then(|v| v.as_u64()).unwrap_or(0);
total_7d += 1;
total_tin_7d += tin;
total_tout_7d += tout;
// 24h 窗口
if now - ts < 86400 {
total_24h += 1;
total_tin_24h += tin;
total_tout_24h += tout;
let age_h = ((now - ts) / 3600) as i64;
let h = (now_h - age_h + 24) % 24; // 倒推到该小时槽
if (0..24).contains(&h) {
hour_24[h as usize] += 1;
}
}
// 按 slot 聚合
let entry = by_slot.entry(slot.to_owned()).or_insert_with(SlotStat::default);
entry.calls_7d += 1;
entry.calls_24h += if now - ts < 86400 { 1 } else { 0 };
entry.tin_7d += tin;
entry.tout_7d += tout;
entry.last_status = status;
if ts >= last_ts {
last_ts = ts;
last_slot = slot.to_owned();
sum.calls += 1;
sum.tin += tin;
sum.tout += tout;
let entry = sum.by_slot.entry(slot.to_owned()).or_default();
entry.calls += 1;
entry.tin += tin;
entry.tout += tout;
if ts >= sum.last_ts {
sum.last_ts = ts;
sum.last_slot = slot.to_owned();
sum.last_status = status;
}
}
}
// by_slot 数组按 calls_7d 降序
let mut slot_vec: Vec<(String, SlotStat)> = by_slot.into_iter().collect();
slot_vec.sort_by(|a, b| b.1.calls_7d.cmp(&a.1.calls_7d));
// 3. 24h hour / 24h totals / 7d by_slot 都是滚动数据 → 重算 24h/7d 范围 audit
// (不持久化,**每次现算**——audit 永远在,量小几百 KB,可接受)
let mut hour_24 = [0u64; 24];
let mut total_24h: u64 = 0;
let mut total_tin_24h: u64 = 0;
let mut total_tout_24h: u64 = 0;
let mut by_slot_7d: std::collections::BTreeMap<String, SlotStat7d> =
std::collections::BTreeMap::new();
for d in &all_days {
let rows = match read_day(d) {
Ok(r) => r,
Err(_) => continue,
};
for r in rows.iter() {
let u = r.get("user").and_then(|v| v.as_str()).unwrap_or("");
if u != username {
continue;
}
let ts = r.get("ts").and_then(|v| v.as_i64()).unwrap_or(0);
if ts > now {
continue;
}
let slot = r.get("slot").and_then(|v| v.as_str()).unwrap_or("-");
let status = r.get("status").and_then(|v| v.as_u64()).unwrap_or(0);
let tin = r.get("tin").and_then(|v| v.as_u64()).unwrap_or(0);
let tout = r.get("tout").and_then(|v| v.as_u64()).unwrap_or(0);
// 24h 窗口
if ts >= cutoff_24h {
total_24h += 1;
total_tin_24h += tin;
total_tout_24h += tout;
let age_h = ((now - ts) / 3600) as i64;
let h = (now_h - age_h + 24) % 24;
if (0..24).contains(&h) {
hour_24[h as usize] += 1;
}
}
// 7d by_slot
if ts >= cutoff_7d {
let entry = by_slot_7d.entry(slot.to_owned()).or_default();
entry.calls += 1;
entry.tin += tin;
entry.tout += tout;
if ts >= cutoff_24h {
entry.calls_24h += 1;
}
entry.last_status = status;
}
}
}
// 4. 写回 shm(增量缓存,下一次从 last_ts 继续累加)
save_user_sum(username, &sum);
// 5. by_slot 数组按 calls 降序;7d totals 从 by_slot_7d 求和
let mut slot_vec: Vec<(String, SlotStat7d)> = by_slot_7d.into_iter().collect();
slot_vec.sort_by(|a, b| b.1.calls.cmp(&a.1.calls));
let mut total_7d: u64 = 0;
let mut total_tin_7d: u64 = 0;
let mut total_tout_7d: u64 = 0;
for (_, st) in &slot_vec {
total_7d += st.calls;
total_tin_7d += st.tin;
total_tout_7d += st.tout;
}
json!({
"calls_24h": total_24h,
@@ -493,25 +576,76 @@ pub fn user_recent(username: &str, days: u32) -> Value {
"by_slot": slot_vec.iter().map(|(s, st)| json!({
"slot": s,
"calls_24h": st.calls_24h,
"calls_7d": st.calls_7d,
"tin_7d": st.tin_7d,
"tout_7d": st.tout_7d,
"calls_7d": st.calls,
"tin_7d": st.tin,
"tout_7d": st.tout,
"last_status": st.last_status,
})).collect::<Vec<_>>(),
"last_at": if last_ts > 0 { json!(util::fmt_time(last_ts)) } else { json!(null) },
"last_slot": if last_ts > 0 { json!(last_slot) } else { json!(null) },
"last_at": if sum.last_ts > 0 { json!(util::fmt_time(sum.last_ts)) } else { json!(null) },
"last_slot": if sum.last_ts > 0 { json!(sum.last_slot) } else { json!(null) },
// 调试字段:运维可看出缓存命中情况(_cached.last_ts == now 表示无新请求)
"_cached": {
"last_ts": sum.last_ts,
"calls": sum.calls,
"tin": sum.tin,
"tout": sum.tout,
},
})
}
#[derive(Default)]
struct SlotStat {
calls_24h: u64,
calls_7d: u64,
tin_7d: u64,
tout_7d: u64,
/// 持久化的每用户累计(shm `usum:<username>` 的 value,JSON 序列化)
///
/// 只存「自上次 stats_persist 恢复以来的全时间累计」,**不**存 24h/7d 滚动数据
/// (滚动窗口会衰减,持久化反而错位)。
///
/// `last_ts` 是关键:下次 user_recent 只扫 `ts > last_ts` 的 delta 行。
#[derive(Default, serde::Serialize, serde::Deserialize)]
struct UserSum {
calls: u64,
tin: u64,
tout: u64,
/// 按 slot 累计(last_ts 之上的全时间累计)
by_slot: std::collections::BTreeMap<String, SlotStat>,
last_ts: i64,
last_slot: String,
last_status: u64,
}
/// 7d 范围 by_slot 聚合(user_recent 内每次现算,**不持久化**)
#[derive(Default)]
struct SlotStat7d {
calls: u64,
calls_24h: u64,
tin: u64,
tout: u64,
last_status: u64,
}
/// 持久化累计的 by_slot 单 slot 值
#[derive(Default, serde::Serialize, serde::Deserialize)]
struct SlotStat {
calls: u64,
tin: u64,
tout: u64,
}
fn load_user_sum(username: &str) -> Option<UserSum> {
let (payload, _exp) = state::get(config::KEY_USER_SUM_PREFIX, username.as_bytes())?;
serde_json::from_str(&payload).ok()
}
fn save_user_sum(username: &str, sum: &UserSum) {
if let Ok(payload) = serde_json::to_string(sum) {
// exp = 0 表示永不过期(持久化累计)
state::put(
config::KEY_USER_SUM_PREFIX,
username.as_bytes(),
payload.as_bytes(),
0,
);
}
}
fn empty_recent() -> Value {
json!({
"calls_24h": 0,
+2 -1
View File
@@ -74,7 +74,7 @@ use ipass_core::{state, store, util};
use crate::config::{
KEY_SPD_PREFIX, KEY_SPR_PREFIX, KEY_UDAY_ACCT_PREFIX, KEY_UDAY_PREFIX,
KEY_UDAY_SLOT_PREFIX, KEY_UDAY_USER_PREFIX, KEY_UEX_PREFIX, KEY_UH_PREFIX, KEY_UMS_PREFIX,
KEY_UTMS_PREFIX, KEY_UST_PREFIX, KEY_UTT_PREFIX, STATS_FILE_NAME,
KEY_UTMS_PREFIX, KEY_UST_PREFIX, KEY_UTT_PREFIX, KEY_USER_SUM_PREFIX, STATS_FILE_NAME,
STATS_PERSIST_INTERVAL_DEFAULT, STATS_SNAPSHOT_VERSION,
};
@@ -93,6 +93,7 @@ const PREFIXES: &[&[u8]] = &[
KEY_UDAY_ACCT_PREFIX, // 按上游账号日桶(「各 Key 负载」)
KEY_UEX_PREFIX, // 账号额度耗尽次数日桶
KEY_UH_PREFIX, // 上游健康展示缓存
KEY_USER_SUM_PREFIX, // 每用户聚合缓存(1.0.32 /api/v1/me 增量)
];
/// 快照值里的分隔符:`<payload>\x1f<exp>`。
+5
View File
@@ -33,6 +33,11 @@
var tokTotal = num(tok.in_total) + num(tok.out_total);
IP.$("statTokToday").textContent = IP.chart.fmtNum(tokToday);
IP.$("statTokTotal").textContent = IP.chart.fmtNum(tokTotal);
// 1.0.32:自服务上线以来累计(来自 audit meta.jsonl 真源,不受 stats 落盘/恢复影响)
var allTime = tok.all_time || {};
var allTimeTokens = num(allTime.tin) + num(allTime.tout);
IP.$("statTokAllTime").textContent = IP.chart.fmtNum(allTimeTokens) +
(allTime.since ? " (" + allTime.since + " 起)" : "");
IP.$("statModels").textContent = distinctModels(s);
}
+1
View File
@@ -21,6 +21,7 @@
<div class="stat"><div class="k">累计调用</div><div class="v" id="statLlmtotal">-</div></div>
<div class="stat"><div class="k">今日 token</div><div class="v" id="statTokToday">-</div></div>
<div class="stat"><div class="k">累计 token</div><div class="v" id="statTokTotal">-</div></div>
<div class="stat"><div class="k" title="自服务上线以来累计(来自 audit meta.jsonl 真源聚合,不受 stats 落盘/恢复影响)">累计 token (自上线)</div><div class="v" id="statTokAllTime">-</div></div>
<div class="stat"><div class="k">可用模型</div><div class="v" id="statModels">-</div></div>
</div>