Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

bound monitor history retention

Raine Virta327f811400bf
diff --git a/src/monitor.rs b/src/monitor.rs
index 811c8b7..f7c1898 100644
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -1,5 +1,5 @@
use std::{
- collections::{HashMap, VecDeque},
+ collections::{HashMap, HashSet, VecDeque},
path::PathBuf,
sync::{Arc, Mutex},
time::{Duration, Instant, SystemTime},
@@ -13,6 +13,9 @@ pub use mock::{MockMonitor, mock_state};
const DEFAULT_RECENT_LIMIT: usize = 200;
pub const SESSION_TOKEN_BUCKET_SECS: u64 = 10;
+pub const SESSION_OUTPUT_HISTORY_BUCKETS: u64 = 60 * 60 / SESSION_TOKEN_BUCKET_SECS;
+const SESSION_USAGE_RETENTION: Duration = Duration::from_secs(24 * 60 * 60);
+const SESSION_PRUNE_INTERVAL: Duration = Duration::from_secs(60);
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
@@ -286,6 +289,7 @@ impl SessionSummary {
struct MonitorStore {
started_at: SystemTime,
started_instant: Instant,
+ last_session_prune_instant: Instant,
active: HashMap<String, ActiveRequest>,
recent: VecDeque<CompletedRequest>,
session_usage: HashMap<Option<String>, SessionUsage>,
@@ -293,10 +297,21 @@ struct MonitorStore {
recent_limit: usize,
}
-#[derive(Debug, Default)]
+#[derive(Debug)]
struct SessionUsage {
input_tokens: u64,
output_tokens: u64,
+ last_seen: SystemTime,
+}
+
+impl Default for SessionUsage {
+ fn default() -> Self {
+ Self {
+ input_tokens: 0,
+ output_tokens: 0,
+ last_seen: SystemTime::now(),
+ }
+ }
}
#[derive(Debug, Clone)]
@@ -316,6 +331,7 @@ impl MonitorHandle {
store: Arc::new(Mutex::new(MonitorStore {
started_at: SystemTime::now(),
started_instant: Instant::now(),
+ last_session_prune_instant: Instant::now(),
active: HashMap::new(),
recent: VecDeque::new(),
session_usage: HashMap::new(),
@@ -333,7 +349,7 @@ impl MonitorHandle {
pub fn snapshot(&self) -> MonitorState {
match self.store.lock() {
- Ok(store) => store.snapshot(),
+ Ok(mut store) => store.snapshot(),
Err(_) => MonitorState {
started_at: SystemTime::now(),
uptime: Duration::ZERO,
@@ -733,6 +749,7 @@ impl MonitorStore {
);
}
}
+ self.prune_session_history_if_due(SystemTime::now());
}
fn finish_active(
@@ -851,6 +868,7 @@ impl MonitorStore {
let usage = self.session_usage.entry(session_id).or_default();
usage.input_tokens = usage.input_tokens.saturating_add(input_tokens);
usage.output_tokens = usage.output_tokens.saturating_add(output_tokens);
+ usage.last_seen = SystemTime::now();
}
fn record_session_output(
@@ -867,7 +885,38 @@ impl MonitorStore {
}
}
- fn snapshot(&self) -> MonitorState {
+ fn prune_session_history_if_due(&mut self, now: SystemTime) {
+ if self.last_session_prune_instant.elapsed() >= SESSION_PRUNE_INTERVAL {
+ self.prune_session_history(now);
+ }
+ }
+
+ fn prune_session_history(&mut self, now: SystemTime) {
+ let retained_sessions: HashSet<_> = self
+ .active
+ .values()
+ .map(|request| request.session_id.clone())
+ .chain(self.recent.iter().map(|request| request.session_id.clone()))
+ .collect();
+ self.session_usage.retain(|session_id, usage| {
+ let retained_by_age = match now.duration_since(usage.last_seen) {
+ Ok(age) => age < SESSION_USAGE_RETENTION,
+ Err(_) => true,
+ };
+ retained_sessions.contains(session_id) || retained_by_age
+ });
+ let first_bucket = first_session_output_bucket(now);
+ for buckets in self.session_output_buckets.values_mut() {
+ buckets.retain(|(bucket, _)| *bucket >= first_bucket);
+ }
+ self.session_output_buckets
+ .retain(|_, buckets| !buckets.is_empty());
+ self.last_session_prune_instant = Instant::now();
+ }
+
+ fn snapshot(&mut self) -> MonitorState {
+ let now = SystemTime::now();
+ self.prune_session_history_if_due(now);
let mut active: Vec<_> = self.active.values().cloned().collect();
active.sort_by_key(|request| request.started_at);
let sessions = session_summaries(
@@ -875,6 +924,7 @@ impl MonitorStore {
&self.recent,
&self.session_usage,
&self.session_output_buckets,
+ now,
);
MonitorState {
started_at: self.started_at,
@@ -891,6 +941,7 @@ fn session_summaries(
recent: &VecDeque<CompletedRequest>,
session_usage: &HashMap<Option<String>, SessionUsage>,
session_output_buckets: &HashMap<Option<String>, Vec<(u64, u64)>>,
+ now: SystemTime,
) -> Vec<SessionSummary> {
let mut sessions: HashMap<Option<String>, SessionSummary> = HashMap::new();
for request in recent.iter().rev() {
@@ -979,6 +1030,7 @@ fn session_summaries(
entry.last_status = request.status.label().to_string();
}
+ let first_bucket = first_session_output_bucket(now);
for (session_id, session) in &mut sessions {
if let Some(usage) = session_usage.get(session_id) {
session.input_tokens = usage.input_tokens;
@@ -987,6 +1039,7 @@ fn session_summaries(
if let Some(buckets) = session_output_buckets.get(session_id) {
session.output_token_samples = buckets
.iter()
+ .filter(|(bucket, _)| *bucket >= first_bucket)
.map(|(bucket, tokens)| (session_token_bucket_start(*bucket), *tokens))
.collect();
}
@@ -1009,6 +1062,10 @@ fn session_token_bucket_start(bucket: u64) -> SystemTime {
SystemTime::UNIX_EPOCH + Duration::from_secs(bucket.saturating_mul(SESSION_TOKEN_BUCKET_SECS))
}
+fn first_session_output_bucket(now: SystemTime) -> u64 {
+ session_token_bucket(now).saturating_sub(SESSION_OUTPUT_HISTORY_BUCKETS.saturating_sub(1))
+}
+
fn update_token_count(current: &mut Option<u64>, incoming: Option<u64>) -> u64 {
let Some(incoming) = incoming else {
return 0;
@@ -1357,7 +1414,7 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
.output_tokens
.saturating_add(request.output_tokens.unwrap_or(0));
}
- session_summaries(&[], recent, &usage, &HashMap::new())
+ session_summaries(&[], recent, &usage, &HashMap::new(), SystemTime::now())
}
#[test]
@@ -1536,6 +1593,158 @@ data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input
);
}
+ #[test]
+ fn session_output_history_prunes_old_buckets_without_changing_totals() {
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started("r1", Some("s1".to_string()), None, EndpointKind::Messages);
+ monitor.request_completed("r1", 200, Some(100), Some(20));
+
+ let now = SystemTime::now();
+ let current_bucket = session_token_bucket(now);
+ {
+ let mut store = monitor.store.lock().unwrap();
+ store
+ .session_output_buckets
+ .get_mut(&Some("s1".into()))
+ .unwrap()
+ .insert(
+ 0,
+ (
+ current_bucket.saturating_sub(SESSION_OUTPUT_HISTORY_BUCKETS),
+ 900,
+ ),
+ );
+ store.prune_session_history(now);
+ assert_eq!(
+ store
+ .session_output_buckets
+ .get(&Some("s1".into()))
+ .unwrap()
+ .len(),
+ 1
+ );
+ }
+
+ let session = &monitor.snapshot().sessions[0];
+
+ assert_eq!(session.input_tokens, 100);
+ assert_eq!(session.output_tokens, 20);
+ assert_eq!(
+ session
+ .output_token_samples
+ .iter()
+ .map(|(_, tokens)| *tokens)
+ .sum::<u64>(),
+ 20
+ );
+ assert!(
+ session
+ .output_token_samples
+ .iter()
+ .all(|(timestamp, _)| session_token_bucket(*timestamp)
+ >= current_bucket.saturating_sub(SESSION_OUTPUT_HISTORY_BUCKETS - 1))
+ );
+ }
+
+ #[test]
+ fn snapshot_filters_old_buckets_before_prune_is_due() {
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started("r1", Some("s1".to_string()), None, EndpointKind::Messages);
+ monitor.request_completed("r1", 200, Some(100), Some(20));
+
+ let now = SystemTime::now();
+ let current_bucket = session_token_bucket(now);
+ let old_bucket = current_bucket.saturating_sub(SESSION_OUTPUT_HISTORY_BUCKETS);
+ {
+ let mut store = monitor.store.lock().unwrap();
+ store
+ .session_output_buckets
+ .get_mut(&Some("s1".into()))
+ .unwrap()
+ .insert(0, (old_bucket, 900));
+ store.last_session_prune_instant = Instant::now();
+ }
+
+ let session = &monitor.snapshot().sessions[0];
+
+ assert_eq!(session.output_tokens, 20);
+ assert_eq!(
+ session
+ .output_token_samples
+ .iter()
+ .map(|(_, tokens)| *tokens)
+ .sum::<u64>(),
+ 20
+ );
+ let store = monitor.store.lock().unwrap();
+ assert!(
+ store
+ .session_output_buckets
+ .get(&Some("s1".into()))
+ .unwrap()
+ .iter()
+ .any(|(bucket, tokens)| *bucket == old_bucket && *tokens == 900)
+ );
+ }
+
+ #[test]
+ fn inactive_session_accounting_expires_without_affecting_active_totals() {
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started(
+ "active",
+ Some("active-session".to_string()),
+ None,
+ EndpointKind::Messages,
+ );
+ monitor.usage_updated("active", Some(12), Some(7));
+ monitor.request_started(
+ "old",
+ Some("old-session".to_string()),
+ None,
+ EndpointKind::Messages,
+ );
+ monitor.request_completed("old", 200, Some(30), Some(11));
+
+ let old_timestamp = SystemTime::now() - SESSION_USAGE_RETENTION - Duration::from_secs(1);
+ let old_bucket = session_token_bucket(old_timestamp);
+ {
+ let mut store = monitor.store.lock().unwrap();
+ store.recent.clear();
+ store
+ .session_usage
+ .get_mut(&Some("active-session".into()))
+ .unwrap()
+ .last_seen = old_timestamp;
+ store
+ .session_usage
+ .get_mut(&Some("old-session".into()))
+ .unwrap()
+ .last_seen = old_timestamp;
+ store
+ .session_output_buckets
+ .insert(Some("old-session".into()), vec![(old_bucket, 11)]);
+ store.last_session_prune_instant = Instant::now() - SESSION_PRUNE_INTERVAL;
+ }
+
+ let state = monitor.snapshot();
+
+ assert_eq!(state.sessions.len(), 1);
+ assert_eq!(state.sessions[0].label(), "active-session");
+ assert_eq!(state.sessions[0].input_tokens, 12);
+ assert_eq!(state.sessions[0].output_tokens, 7);
+ let store = monitor.store.lock().unwrap();
+ assert!(
+ !store
+ .session_usage
+ .contains_key(&Some("old-session".into()))
+ );
+ assert!(
+ !store
+ .session_output_buckets
+ .contains_key(&Some("old-session".into()))
+ );
+ }
+
#[test]
fn session_usage_ignores_decreasing_request_observations() {
let monitor = MonitorHandle::new(10);
diff --git a/src/monitor/mock.rs b/src/monitor/mock.rs
index 48846d1..fbbc22c 100644
--- a/src/monitor/mock.rs
+++ b/src/monitor/mock.rs
@@ -368,7 +368,7 @@ fn mock_state_for_tick(
.output_tokens
.saturating_add(request.output_tokens.unwrap_or(0));
}
- let sessions = session_summaries(&active, &recent, &session_usage, output_buckets);
+ let sessions = session_summaries(&active, &recent, &session_usage, output_buckets, now);
MonitorState {
started_at,
uptime: now.duration_since(started_at).unwrap_or_default(),