Files
codex-proxy-rs/backend/tests/telemetry/usage/store.rs
T
2026-07-12 10:07:21 +08:00

311 lines
10 KiB
Rust

use chrono::{Duration, Utc};
use codex_proxy_rs::telemetry::{
usage::store::{PgUsageRecordStore, UsageRecordFilter},
usage::types::UsageRecord,
};
use crate::support::storage::init_test_db;
#[tokio::test]
async fn usage_store_should_filter_numbered_pages_of_success_facts() {
let (pool, _guard) = init_test_db("usage-record-filter").await;
let store = PgUsageRecordStore::new(pool);
let mut matching = success_record("matching");
matching.id = "usage_matching".to_string();
matching.request_id = Some("req_1".to_string());
matching.route = Some("/v1/responses".to_string());
matching.client_api_key_id = Some("key_1".to_string());
store.append(&matching).await.unwrap();
store.append(&success_record("other")).await.unwrap();
let page = store
.list_page(
UsageRecordFilter {
kind: Some("request".to_string()),
client_api_key_id: Some("key_1".to_string()),
search: Some("matching".to_string()),
..UsageRecordFilter::default()
},
1,
20,
)
.await
.unwrap();
assert_eq!(page.total, 1);
assert_eq!(page.items[0].id, "usage_matching");
assert_eq!(page.items[0].request_id.as_deref(), Some("req_1"));
}
#[tokio::test]
async fn usage_store_should_apply_every_query_filter_dimension() {
let (pool, _guard) = init_test_db("usage-record-filter-matrix").await;
let store = PgUsageRecordStore::new(pool);
let now = Utc::now();
let mut matching = success_record("needle message");
matching.id = "usage_matrix_matching".to_string();
matching.kind = "response".to_string();
matching.client_api_key_id = Some("key_matching".to_string());
matching.provider = "provider_matching".to_string();
matching.request_id = Some("request_matching".to_string());
matching.account_id = "account_matching".to_string();
matching.route = Some("/v1/matching".to_string());
matching.model = "model_matching".to_string();
matching.status_code = 201;
matching.transport = Some("websocket".to_string());
matching.attempt_index = Some(3);
matching.response_id = Some("response_matching".to_string());
matching.upstream_request_id = Some("upstream_matching".to_string());
matching.created_at = now;
store.append(&matching).await.unwrap();
let mut other = success_record("other message");
other.id = "usage_matrix_other".to_string();
other.kind = "other".to_string();
other.client_api_key_id = Some("key_other".to_string());
other.provider = "provider_other".to_string();
other.request_id = Some("request_other".to_string());
other.account_id = "account_other".to_string();
other.route = Some("/v1/other".to_string());
other.model = "model_other".to_string();
other.status_code = 202;
other.transport = Some("http_sse".to_string());
other.attempt_index = Some(4);
other.response_id = Some("response_other".to_string());
other.upstream_request_id = Some("upstream_other".to_string());
other.created_at = now - Duration::hours(2);
store.append(&other).await.unwrap();
let filters = vec![
(
"kind",
UsageRecordFilter {
kind: Some(matching.kind.clone()),
..Default::default()
},
),
(
"client key",
UsageRecordFilter {
client_api_key_id: matching.client_api_key_id.clone(),
..Default::default()
},
),
(
"provider",
UsageRecordFilter {
provider: Some(matching.provider.clone()),
..Default::default()
},
),
(
"request",
UsageRecordFilter {
request_id: matching.request_id.clone(),
..Default::default()
},
),
(
"account",
UsageRecordFilter {
account_id: Some(matching.account_id.clone()),
..Default::default()
},
),
(
"route",
UsageRecordFilter {
route: matching.route.clone(),
..Default::default()
},
),
(
"model",
UsageRecordFilter {
model: Some(matching.model.clone()),
..Default::default()
},
),
(
"status",
UsageRecordFilter {
status_code: Some(matching.status_code),
..Default::default()
},
),
(
"transport",
UsageRecordFilter {
transport: matching.transport.clone(),
..Default::default()
},
),
(
"attempt",
UsageRecordFilter {
attempt_index: matching.attempt_index,
..Default::default()
},
),
(
"response",
UsageRecordFilter {
response_id: matching.response_id.clone(),
..Default::default()
},
),
(
"upstream request",
UsageRecordFilter {
upstream_request_id: matching.upstream_request_id.clone(),
..Default::default()
},
),
(
"message search",
UsageRecordFilter {
search: Some("needle message".to_string()),
..Default::default()
},
),
(
"request search",
UsageRecordFilter {
search: matching.request_id.clone(),
..Default::default()
},
),
(
"response search",
UsageRecordFilter {
search: matching.response_id.clone(),
..Default::default()
},
),
(
"upstream search",
UsageRecordFilter {
search: matching.upstream_request_id.clone(),
..Default::default()
},
),
(
"time window",
UsageRecordFilter {
start_time: Some(now - Duration::minutes(1)),
end_time: Some(now + Duration::minutes(1)),
..Default::default()
},
),
];
for (dimension, filter) in filters {
let page = store.list_page(filter, 1, 20).await.unwrap();
assert_eq!(page.total, 1, "{dimension}");
assert_eq!(page.items[0].id, matching.id, "{dimension}");
}
}
#[tokio::test]
async fn usage_store_should_list_recent_records_in_descending_order() {
let (pool, _guard) = init_test_db("usage-record-recent").await;
let store = PgUsageRecordStore::new(pool);
let now = Utc::now();
for (id, seconds) in [("usage_old", 0), ("usage_middle", 1), ("usage_new", 2)] {
let mut record = success_record(id);
record.id = id.to_string();
record.created_at = now + Duration::seconds(seconds);
store.append(&record).await.unwrap();
}
let records = store
.list_recent(UsageRecordFilter::default(), 2)
.await
.unwrap();
assert_eq!(
records
.iter()
.map(|record| record.id.as_str())
.collect::<Vec<_>>(),
["usage_new", "usage_middle"]
);
}
#[tokio::test]
async fn usage_record_and_bucket_are_one_transaction_and_keep_zero_ms_samples() {
let (pool, _guard) = init_test_db("usage-record-transaction").await;
let store = PgUsageRecordStore::new(pool.clone());
let mut record = success_record("zero latency");
record.id = "usage_zero_ms".to_string();
record.latency_ms = Some(0);
record.first_token_ms = Some(0);
record.input_tokens = Some(11);
record.output_tokens = Some(7);
record.service_tier = Some("priority".to_string());
store.append(&record).await.unwrap();
let bucket: (i64, i64, i64, i64, i64, String) = sqlx::query_as(
"select success_count, input_tokens, output_tokens, latency_count,
first_token_latency_count, service_tier
from request_time_buckets where account_id = $1 and model = $2",
)
.bind(&record.account_id)
.bind(&record.model)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(bucket, (1, 11, 7, 1, 1, "priority".to_string()));
sqlx::raw_sql(
"create function reject_test_bucket() returns trigger language plpgsql as $$
begin raise exception 'bucket rejected'; end $$;
create trigger reject_test_bucket before insert or update on request_time_buckets
for each row execute function reject_test_bucket();",
)
.execute(&pool)
.await
.unwrap();
let mut rejected = success_record("must rollback");
rejected.id = "usage_rolled_back".to_string();
assert!(store.append(&rejected).await.is_err());
let count: i64 = sqlx::query_scalar("select count(*) from usage_records where id = $1")
.bind(&rejected.id)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(count, 0);
}
#[tokio::test]
async fn usage_store_trims_by_runtime_retention() {
let (pool, _guard) = init_test_db("usage-record-retention").await;
sqlx::query(
"insert into runtime_settings (
id, refresh_margin_seconds, refresh_concurrency,
max_concurrent_per_account, request_interval_ms,
rotation_strategy, updated_at
) values (1, 3600, 2, 1, 0, 'smart', now())",
)
.execute(&pool)
.await
.unwrap();
let store = PgUsageRecordStore::new(pool);
let now = Utc::now();
let mut expired = success_record("expired");
expired.id = "usage_expired".to_string();
expired.created_at = now - Duration::days(31);
store.append(&expired).await.unwrap();
let mut retained = success_record("retained");
retained.id = "usage_retained".to_string();
retained.created_at = now - Duration::days(29);
store.append(&retained).await.unwrap();
assert_eq!(store.trim_to_retention(now).await.unwrap(), 1);
assert!(store.get("usage_expired").await.unwrap().is_none());
assert!(store.get("usage_retained").await.unwrap().is_some());
}
fn success_record(message: &str) -> UsageRecord {
UsageRecord::new("request", message, "acct_usage", "gpt-5", 200)
}