admin/CC-Switch
1
0
Fork 0
mirror of https://github.com/farion1231/cc-switch.git synced 2026-08-02 10:21:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: add usage daily rollups, incremental auto-vacuum, and sync-aware backup

Browse Source 
- Add usage_daily_rollups table (schema v6) to aggregate proxy request
  logs into daily summaries, reducing query overhead for statistics
- Add rollup_and_prune DAO that aggregates old detail logs (>N days)
  into rollup rows and deletes the originals
- Update all usage stats queries to UNION detail logs with rollup data
- Introduce incremental auto-vacuum for SQLite, with startup and
  periodic cleanup of old stream_check_logs and request log rollups
- Split backup export/import into full vs sync variants: WebDAV sync
  now skips local-only table data (proxy_request_logs,
  stream_check_logs, provider_health, proxy_live_backup,
  usage_daily_rollups) while preserving them on import
- Add enable_logging guard to skip request log writes when disabled
- Apply cargo fmt formatting fixes across multiple modules
This commit is contained in:
Jason
2026-03-08 17:18:21 +08:00
parent 3f711d6504
commit bf40b0138c
16 changed files with 910 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/src/services/usage_stats.rs
+200 -45
View File
@@ -142,20 +142,60 @@ impl Database {
(String::new(), Vec::new())
};
// Build rollup WHERE clause using date strings (use ? for sequential binding)
let (rollup_where, rollup_params) = if start_date.is_some() || end_date.is_some() {
let mut conditions: Vec<String> = Vec::new();
let mut params = Vec::new();
if let Some(start) = start_date {
conditions.push("date >= date(?, 'unixepoch', 'localtime')".to_string());
params.push(start);
}
if let Some(end) = end_date {
conditions.push("date <= date(?, 'unixepoch', 'localtime')".to_string());
params.push(end);
}
(format!("WHERE {}", conditions.join(" AND ")), params)
} else {
(String::new(), Vec::new())
};
let sql = format!(
"SELECT
COUNT(*) as total_requests,
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost,
COALESCE(SUM(input_tokens), 0) as total_input_tokens,
COALESCE(SUM(output_tokens), 0) as total_output_tokens,
COALESCE(SUM(cache_creation_tokens), 0) as total_cache_creation_tokens,
COALESCE(SUM(cache_read_tokens), 0) as total_cache_read_tokens,
COALESCE(SUM(CASE WHEN status_code >= 200 AND status_code < 300 THEN 1 ELSE 0 END), 0) as success_count
FROM proxy_request_logs
{where_clause}"
COALESCE(d.total_requests, 0) + COALESCE(r.total_requests, 0),
COALESCE(d.total_cost, 0) + COALESCE(r.total_cost, 0),
COALESCE(d.total_input_tokens, 0) + COALESCE(r.total_input_tokens, 0),
COALESCE(d.total_output_tokens, 0) + COALESCE(r.total_output_tokens, 0),
COALESCE(d.total_cache_creation_tokens, 0) + COALESCE(r.total_cache_creation_tokens, 0),
COALESCE(d.total_cache_read_tokens, 0) + COALESCE(r.total_cache_read_tokens, 0),
COALESCE(d.success_count, 0) + COALESCE(r.success_count, 0)
FROM
(SELECT
COUNT(*) as total_requests,
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost,
COALESCE(SUM(input_tokens), 0) as total_input_tokens,
COALESCE(SUM(output_tokens), 0) as total_output_tokens,
COALESCE(SUM(cache_creation_tokens), 0) as total_cache_creation_tokens,
COALESCE(SUM(cache_read_tokens), 0) as total_cache_read_tokens,
COALESCE(SUM(CASE WHEN status_code >= 200 AND status_code < 300 THEN 1 ELSE 0 END), 0) as success_count
FROM proxy_request_logs {where_clause}) d,
(SELECT
COALESCE(SUM(request_count), 0) as total_requests,
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost,
COALESCE(SUM(input_tokens), 0) as total_input_tokens,
COALESCE(SUM(output_tokens), 0) as total_output_tokens,
COALESCE(SUM(cache_creation_tokens), 0) as total_cache_creation_tokens,
COALESCE(SUM(cache_read_tokens), 0) as total_cache_read_tokens,
COALESCE(SUM(success_count), 0) as success_count
FROM usage_daily_rollups {rollup_where}) r"
);
let result = conn.query_row(&sql, rusqlite::params_from_iter(params_vec), |row| {
// Combine params: detail params first, then rollup params
let mut all_params: Vec<i64> = params_vec;
all_params.extend(rollup_params);
let result = conn.query_row(&sql, rusqlite::params_from_iter(all_params), |row| {
let total_requests: i64 = row.get(0)?;
let total_cost: f64 = row.get(1)?;
let total_input_tokens: i64 = row.get(2)?;
@@ -220,6 +260,7 @@ impl Database {
bucket_count = 1;
}
// Query detail logs
let sql = "
SELECT
CAST((created_at - ?1) / ?3 AS INTEGER) as bucket_idx,
@@ -264,6 +305,68 @@ impl Database {
map.insert(bucket_idx, stat);
}
// Also query rollup data (daily granularity, only useful for daily buckets)
if bucket_seconds >= 86400 {
let rollup_sql = "
SELECT
CAST((CAST(strftime('%s', date) AS INTEGER) - ?1) / ?3 AS INTEGER) as bucket_idx,
COALESCE(SUM(request_count), 0),
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0),
COALESCE(SUM(input_tokens + output_tokens), 0),
COALESCE(SUM(input_tokens), 0),
COALESCE(SUM(output_tokens), 0),
COALESCE(SUM(cache_creation_tokens), 0),
COALESCE(SUM(cache_read_tokens), 0)
FROM usage_daily_rollups
WHERE date >= date(?1, 'unixepoch', 'localtime') AND date <= date(?2, 'unixepoch', 'localtime')
GROUP BY bucket_idx
ORDER BY bucket_idx ASC";
let mut rstmt = conn.prepare(rollup_sql)?;
let rrows = rstmt.query_map(params![start_ts, end_ts, bucket_seconds], |row| {
Ok((
row.get::<_, i64>(0)?,
(
row.get::<_, i64>(1)? as u64,
row.get::<_, f64>(2)?,
row.get::<_, i64>(3)? as u64,
row.get::<_, i64>(4)? as u64,
row.get::<_, i64>(5)? as u64,
row.get::<_, i64>(6)? as u64,
row.get::<_, i64>(7)? as u64,
),
))
})?;
for row in rrows {
let (mut bucket_idx, (req, cost, tok, inp, out, cc, cr)) = row?;
if bucket_idx < 0 {
continue;
}
if bucket_idx >= bucket_count {
bucket_idx = bucket_count - 1;
}
let entry = map.entry(bucket_idx).or_insert_with(|| DailyStats {
date: String::new(),
request_count: 0,
total_cost: "0.000000".to_string(),
total_tokens: 0,
total_input_tokens: 0,
total_output_tokens: 0,
total_cache_creation_tokens: 0,
total_cache_read_tokens: 0,
});
entry.request_count += req;
let existing_cost: f64 = entry.total_cost.parse().unwrap_or(0.0);
entry.total_cost = format!("{:.6}", existing_cost + cost);
entry.total_tokens += tok;
entry.total_input_tokens += inp;
entry.total_output_tokens += out;
entry.total_cache_creation_tokens += cc;
entry.total_cache_read_tokens += cr;
}
}
let mut stats = Vec::with_capacity(bucket_count as usize);
for i in 0..bucket_count {
let bucket_start_ts = start_ts + i * bucket_seconds;
@@ -298,23 +401,46 @@ impl Database {
pub fn get_provider_stats(&self) -> Result<Vec<ProviderStats>, AppError> {
let conn = lock_conn!(self.conn);
// UNION detail logs + rollup data, then aggregate
let sql = "SELECT
l.provider_id,
p.name as provider_name,
COUNT(*) as request_count,
COALESCE(SUM(l.input_tokens + l.output_tokens), 0) as total_tokens,
COALESCE(SUM(CAST(l.total_cost_usd AS REAL)), 0) as total_cost,
COALESCE(SUM(CASE WHEN l.status_code >= 200 AND l.status_code < 300 THEN 1 ELSE 0 END), 0) as success_count,
COALESCE(AVG(l.latency_ms), 0) as avg_latency
FROM proxy_request_logs l
LEFT JOIN providers p ON l.provider_id = p.id AND l.app_type = p.app_type
GROUP BY l.provider_id, l.app_type
ORDER BY total_cost DESC";
provider_id, app_type, provider_name,
SUM(request_count) as request_count,
SUM(total_tokens) as total_tokens,
SUM(total_cost) as total_cost,
SUM(success_count) as success_count,
CASE WHEN SUM(request_count) > 0
THEN SUM(latency_sum) / SUM(request_count)
ELSE 0 END as avg_latency
FROM (
SELECT l.provider_id, l.app_type,
p.name as provider_name,
COUNT(*) as request_count,
COALESCE(SUM(l.input_tokens + l.output_tokens), 0) as total_tokens,
COALESCE(SUM(CAST(l.total_cost_usd AS REAL)), 0) as total_cost,
COALESCE(SUM(CASE WHEN l.status_code >= 200 AND l.status_code < 300 THEN 1 ELSE 0 END), 0) as success_count,
COALESCE(SUM(l.latency_ms), 0) as latency_sum
FROM proxy_request_logs l
LEFT JOIN providers p ON l.provider_id = p.id AND l.app_type = p.app_type
GROUP BY l.provider_id, l.app_type
UNION ALL
SELECT r.provider_id, r.app_type,
p2.name as provider_name,
COALESCE(SUM(r.request_count), 0),
COALESCE(SUM(r.input_tokens + r.output_tokens), 0),
COALESCE(SUM(CAST(r.total_cost_usd AS REAL)), 0),
COALESCE(SUM(r.success_count), 0),
COALESCE(SUM(r.avg_latency_ms * r.request_count), 0)
FROM usage_daily_rollups r
LEFT JOIN providers p2 ON r.provider_id = p2.id AND r.app_type = p2.app_type
GROUP BY r.provider_id, r.app_type
)
GROUP BY provider_id, app_type
ORDER BY total_cost DESC";
let mut stmt = conn.prepare(sql)?;
let rows = stmt.query_map([], |row| {
let request_count: i64 = row.get(2)?;
let success_count: i64 = row.get(5)?;
let request_count: i64 = row.get(3)?;
let success_count: i64 = row.get(6)?;
let success_rate = if request_count > 0 {
(success_count as f32 / request_count as f32) * 100.0
} else {
@@ -324,13 +450,13 @@ impl Database {
Ok(ProviderStats {
provider_id: row.get(0)?,
provider_name: row
.get::<_, Option<String>>(1)?
.get::<_, Option<String>>(2)?
.unwrap_or_else(|| "Unknown".to_string()),
request_count: request_count as u64,
total_tokens: row.get::<_, i64>(3)? as u64,
total_cost: format!("{:.6}", row.get::<_, f64>(4)?),
total_tokens: row.get::<_, i64>(4)? as u64,
total_cost: format!("{:.6}", row.get::<_, f64>(5)?),
success_rate,
avg_latency_ms: row.get::<_, f64>(6)? as u64,
avg_latency_ms: row.get::<_, f64>(7)? as u64,
})
})?;
@@ -346,14 +472,29 @@ impl Database {
pub fn get_model_stats(&self) -> Result<Vec<ModelStats>, AppError> {
let conn = lock_conn!(self.conn);
// UNION detail logs + rollup data
let sql = "SELECT
model,
COUNT(*) as request_count,
COALESCE(SUM(input_tokens + output_tokens), 0) as total_tokens,
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost
FROM proxy_request_logs
GROUP BY model
ORDER BY total_cost DESC";
SUM(request_count) as request_count,
SUM(total_tokens) as total_tokens,
SUM(total_cost) as total_cost
FROM (
SELECT model,
COUNT(*) as request_count,
COALESCE(SUM(input_tokens + output_tokens), 0) as total_tokens,
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0) as total_cost
FROM proxy_request_logs
GROUP BY model
UNION ALL
SELECT model,
COALESCE(SUM(request_count), 0),
COALESCE(SUM(input_tokens + output_tokens), 0),
COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0)
FROM usage_daily_rollups
GROUP BY model
)
GROUP BY model
ORDER BY total_cost DESC";
let mut stmt = conn.prepare(sql)?;
let rows = stmt.query_map([], |row| {
@@ -607,26 +748,40 @@ impl Database {
})
.unwrap_or((None, None));
// 计算今日使用量
// 计算今日使用量 (detail logs + rollup)
let daily_usage: f64 = conn
.query_row(
"SELECT COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0)
FROM proxy_request_logs
WHERE provider_id = ? AND app_type = ?
AND date(datetime(created_at, 'unixepoch', 'localtime')) = date('now', 'localtime')",
params![provider_id, app_type],
"SELECT COALESCE(SUM(cost), 0) FROM (
SELECT CAST(total_cost_usd AS REAL) as cost
FROM proxy_request_logs
WHERE provider_id = ? AND app_type = ?
AND date(datetime(created_at, 'unixepoch', 'localtime')) = date('now', 'localtime')
UNION ALL
SELECT CAST(total_cost_usd AS REAL)
FROM usage_daily_rollups
WHERE provider_id = ? AND app_type = ?
AND date = date('now', 'localtime')
)",
params![provider_id, app_type, provider_id, app_type],
|row| row.get(0),
)
.unwrap_or(0.0);
// 计算本月使用量
// 计算本月使用量 (detail logs + rollup)
let monthly_usage: f64 = conn
.query_row(
"SELECT COALESCE(SUM(CAST(total_cost_usd AS REAL)), 0)
FROM proxy_request_logs
WHERE provider_id = ? AND app_type = ?
AND strftime('%Y-%m', datetime(created_at, 'unixepoch', 'localtime')) = strftime('%Y-%m', 'now', 'localtime')",
params![provider_id, app_type],
"SELECT COALESCE(SUM(cost), 0) FROM (
SELECT CAST(total_cost_usd AS REAL) as cost
FROM proxy_request_logs
WHERE provider_id = ? AND app_type = ?
AND strftime('%Y-%m', datetime(created_at, 'unixepoch', 'localtime')) = strftime('%Y-%m', 'now', 'localtime')
UNION ALL
SELECT CAST(total_cost_usd AS REAL)
FROM usage_daily_rollups
WHERE provider_id = ? AND app_type = ?
AND strftime('%Y-%m', date) = strftime('%Y-%m', 'now', 'localtime')
)",
params![provider_id, app_type, provider_id, app_type],
|row| row.get(0),
)
.unwrap_or(0.0);
src-tauri/src/services/webdav.rs
+2 -2
View File
@@ -477,7 +477,7 @@ mod tests {
"https://dav.example.com/remote.php/dav/files/demo/",
&[
"cc switch-sync".to_string(),
"v2".to_string(),
"v3".to_string(),
"default profile".to_string(),
"manifest.json".to_string(),
],
@@ -485,7 +485,7 @@ mod tests {
.unwrap();
assert_eq!(
url,
"https://dav.example.com/remote.php/dav/files/demo/cc%20switch-sync/v2/default%20profile/manifest.json"
"https://dav.example.com/remote.php/dav/files/demo/cc%20switch-sync/v3/default%20profile/manifest.json"
);
assert!(!url.contains("//cc"), "should not have double-slash");
}
src-tauri/src/services/webdav_sync.rs
+6 -6
View File
@@ -1,4 +1,4 @@
//! WebDAV v2 sync protocol layer.
//! WebDAV v3 sync protocol layer.
//!
//! Implements manifest-based synchronization on top of the HTTP transport
//! primitives in [`super::webdav`]. Artifact set: `db.sql` + `skills.zip`.
@@ -30,7 +30,7 @@ use archive::{
// ─── Protocol constants ──────────────────────────────────────
const PROTOCOL_FORMAT: &str = "cc-switch-webdav-sync";
const PROTOCOL_VERSION: u32 = 2;
const PROTOCOL_VERSION: u32 = 3;
const REMOTE_DB_SQL: &str = "db.sql";
const REMOTE_SKILLS_ZIP: &str = "skills.zip";
const REMOTE_MANIFEST: &str = "manifest.json";
@@ -267,7 +267,7 @@ fn build_local_snapshot(
_settings: &WebDavSyncSettings,
) -> Result<LocalSnapshot, AppError> {
// Export database to SQL string
let sql_string = db.export_sql_string()?;
let sql_string = db.export_sql_string_for_sync()?;
let db_sql = sql_string.into_bytes();
// Pack skills into deterministic ZIP
@@ -492,7 +492,7 @@ fn apply_snapshot(
// 先替换 skills，再导入数据库；若导入失败则回滚 skills，避免“半恢复”。
restore_skills_zip(skills_zip)?;
if let Err(db_err) = db.import_sql_string(sql_str) {
if let Err(db_err) = db.import_sql_string_for_sync(sql_str) {
if let Err(rollback_err) = restore_skills_from_backup(&skills_backup) {
return Err(localized(
"webdav.sync.db_import_and_rollback_failed",
@@ -579,14 +579,14 @@ mod tests {
}
#[test]
fn remote_dir_segments_uses_v2() {
fn remote_dir_segments_uses_v3() {
let settings = WebDavSyncSettings {
remote_root: "cc-switch-sync".to_string(),
profile: "default".to_string(),
..WebDavSyncSettings::default()
};
let segs = remote_dir_segments(&settings);
assert_eq!(segs, vec!["cc-switch-sync", "v2", "default"]);
assert_eq!(segs, vec!["cc-switch-sync", "v3", "default"]);
}
#[test]