Skip to content

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

Rust

anchor activity graphs to producer snapshot time

Raine Virtad00dda8620d2
diff --git a/src/monitor/snapshot.rs b/src/monitor/snapshot.rs
index 2130069..d6328c0 100644
--- a/src/monitor/snapshot.rs
+++ b/src/monitor/snapshot.rs
@@ -12,6 +12,10 @@ use std::{
pub const PROTOCOL_VERSION: u32 = 1;
+fn default_snapshot_at() -> SystemTime {
+ SystemTime::now()
+}
+
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MonitorResponse {
pub version: u32,
@@ -66,6 +70,8 @@ impl SnapshotUpdate {
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MonitorSnapshot {
pub started_at: SystemTime,
+ #[serde(default = "default_snapshot_at")]
+ pub snapshot_at: SystemTime,
pub uptime: Duration,
pub sessions: Vec<SessionSnapshot>,
pub active: Vec<ActiveSnapshot>,
@@ -76,6 +82,7 @@ impl From<MonitorState> for MonitorSnapshot {
fn from(state: MonitorState) -> Self {
Self {
started_at: state.started_at,
+ snapshot_at: SystemTime::now(),
uptime: state.uptime,
sessions: state.sessions.into_iter().map(Into::into).collect(),
active: state.active.into_iter().map(Into::into).collect(),
@@ -294,10 +301,28 @@ mod tests {
assert!(!encoded.contains("instant"));
let decoded: MonitorSnapshot = serde_json::from_str(&encoded).unwrap();
assert_eq!(decoded, snapshot);
+ assert_eq!(decoded.snapshot_at, snapshot.snapshot_at);
assert_eq!(decoded.uptime, snapshot.uptime);
assert_eq!(decoded.active[0].elapsed(), snapshot.active[0].elapsed());
assert_eq!(decoded.active[0].rate(), snapshot.active[0].rate());
assert_eq!(decoded.sessions[0].rate(), snapshot.sessions[0].rate());
assert_eq!(decoded.recent[0].http_status, Some(200));
}
+
+ #[test]
+ fn snapshot_deserialization_accepts_legacy_and_newer_fields() {
+ let snapshot: MonitorSnapshot = MonitorHandle::default().snapshot().into();
+ let mut legacy = serde_json::to_value(&snapshot).unwrap();
+ legacy.as_object_mut().unwrap().remove("snapshot_at");
+ let decoded: MonitorSnapshot = serde_json::from_value(legacy).unwrap();
+ assert!(decoded.snapshot_at >= snapshot.started_at);
+
+ let mut newer = serde_json::to_value(&snapshot).unwrap();
+ newer
+ .as_object_mut()
+ .unwrap()
+ .insert("future_field".into(), serde_json::json!(true));
+ let decoded: MonitorSnapshot = serde_json::from_value(newer).unwrap();
+ assert_eq!(decoded.snapshot_at, snapshot.snapshot_at);
+ }
}
diff --git a/src/tui.rs b/src/tui.rs
index a078798..08967a2 100644
--- a/src/tui.rs
+++ b/src/tui.rs
@@ -456,6 +456,7 @@ fn render(frame: &mut ratatui::Frame<'_>, app: &mut MonitorApp, state: &MonitorS
&state.sessions,
app.selected,
app.focus == FocusPane::Sessions,
+ state.snapshot_at,
),
}
render_active(frame, root[2], &state.active, app.tick);
@@ -751,7 +752,11 @@ fn sparkline_bucket(timestamp: SystemTime) -> u64 {
/ SESSION_TOKEN_BUCKET_SECS
}
-fn token_sparkline(samples: &[(SystemTime, u64)], width: usize, now: SystemTime) -> String {
+fn token_sparkline(
+ samples: &[(SystemTime, u64)],
+ width: usize,
+ reference_at: SystemTime,
+) -> String {
const LEVELS: [char; 8] = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
if width == 0 {
@@ -765,7 +770,7 @@ fn token_sparkline(samples: &[(SystemTime, u64)], width: usize, now: SystemTime)
*total = total.saturating_add(*tokens);
}
- let current_bucket = sparkline_bucket(now);
+ let current_bucket = sparkline_bucket(reference_at);
let first_bucket = current_bucket.saturating_sub(width.saturating_sub(1) as u64);
(first_bucket..=current_bucket)
.map(|bucket| {
@@ -785,9 +790,9 @@ fn token_sparkline(samples: &[(SystemTime, u64)], width: usize, now: SystemTime)
fn token_sparkline_line(
samples: &[(SystemTime, u64)],
width: usize,
- now: SystemTime,
+ reference_at: SystemTime,
) -> Line<'static> {
- let mut sparkline = token_sparkline(samples, width, now);
+ let mut sparkline = token_sparkline(samples, width, reference_at);
let current = sparkline
.pop()
.map_or_else(String::new, |value| value.to_string());
@@ -904,6 +909,7 @@ fn render_sessions(
sessions: &[SessionSnapshot],
selected: usize,
focused: bool,
+ snapshot_at: SystemTime,
) {
if sessions.is_empty() {
render_empty_table_state(frame, area, "Sessions", focused, "No sessions");
@@ -914,7 +920,6 @@ fn render_sessions(
let show_full_sparkline = tier == LayoutTier::Wide && area.width >= SESSION_SPARKLINE_MIN_WIDTH;
let columns = session_columns(tier, show_full_sparkline);
let widths = column_constraints(&columns);
- let now = SystemTime::now();
let rows = sessions.iter().enumerate().map(|(index, session)| {
let cells = columns
.iter()
@@ -955,7 +960,7 @@ fn render_sessions(
SessionColumn::Activity => Cell::from(token_sparkline_line(
&session.output_token_samples,
width,
- now,
+ snapshot_at,
)),
SessionColumn::Status => status_cell(&session.last_status),
}
@@ -2176,6 +2181,68 @@ mod tests {
assert_eq!(token_sparkline(&[(now, 10_000)], 1, now), "█");
}
+ #[test]
+ fn activity_graph_ignores_positive_viewer_clock_skew() {
+ let snapshot_at = SystemTime::UNIX_EPOCH + Duration::from_secs(10_000);
+ let viewer_now = snapshot_at + Duration::from_secs(3_600);
+ let samples = [(snapshot_at, 4_000)];
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started(
+ "request-1",
+ Some("session-1".into()),
+ Some(1),
+ EndpointKind::Messages,
+ );
+ monitor.request_completed("request-1", 200, Some(10), Some(4_000));
+ let mut snapshot: MonitorSnapshot = monitor.snapshot().into();
+ snapshot.snapshot_at = snapshot_at;
+ snapshot.sessions[0].output_token_samples = samples.into();
+
+ assert_eq!(token_sparkline(&samples, 4, viewer_now), " ");
+ let rendered = draw(90, 8, |frame| {
+ render_sessions(
+ frame,
+ frame.area(),
+ &snapshot.sessions,
+ 0,
+ true,
+ snapshot.snapshot_at,
+ )
+ });
+ assert!(buffer_text(&rendered).contains('█'));
+ }
+
+ #[test]
+ fn activity_graph_ignores_negative_viewer_clock_skew() {
+ let snapshot_at = SystemTime::UNIX_EPOCH + Duration::from_secs(10_000);
+ let viewer_now = snapshot_at - Duration::from_secs(3_600);
+ let samples = [(snapshot_at, 4_000)];
+ let monitor = MonitorHandle::new(10);
+ monitor.request_started(
+ "request-1",
+ Some("session-1".into()),
+ Some(1),
+ EndpointKind::Messages,
+ );
+ monitor.request_completed("request-1", 200, Some(10), Some(4_000));
+ let mut snapshot: MonitorSnapshot = monitor.snapshot().into();
+ snapshot.snapshot_at = snapshot_at;
+ snapshot.sessions[0].output_token_samples = samples.into();
+
+ assert_eq!(token_sparkline(&samples, 4, viewer_now), " ");
+ let rendered = draw(90, 8, |frame| {
+ render_sessions(
+ frame,
+ frame.area(),
+ &snapshot.sessions,
+ 0,
+ true,
+ snapshot.snapshot_at,
+ )
+ });
+ assert!(buffer_text(&rendered).contains('█'));
+ }
+
#[test]
fn token_sparkline_dims_the_current_bucket() {
let now = SystemTime::UNIX_EPOCH + Duration::from_secs(100);
@@ -2209,7 +2276,14 @@ mod tests {
let state: MonitorSnapshot = monitor.snapshot().into();
let render_at = |width| {
let buffer = draw(width, 8, |frame| {
- render_sessions(frame, frame.area(), &state.sessions, 0, true)
+ render_sessions(
+ frame,
+ frame.area(),
+ &state.sessions,
+ 0,
+ true,
+ state.snapshot_at,
+ )
});
buffer_text(&buffer)
};
@@ -2243,7 +2317,7 @@ mod tests {
#[test]
fn empty_tables_hide_columns_and_center_placeholders() {
let sessions = draw(40, 9, |frame| {
- render_sessions(frame, frame.area(), &[], 0, true)
+ render_sessions(frame, frame.area(), &[], 0, true, SystemTime::now())
});
let sessions_text = buffer_text(&sessions);
assert_centered(&sessions, "No sessions", 4);
@@ -2321,7 +2395,14 @@ mod tests {
let active_state: MonitorSnapshot = monitor.snapshot().into();
let sessions = draw(170, 8, |frame| {
- render_sessions(frame, frame.area(), &active_state.sessions, 0, true)
+ render_sessions(
+ frame,
+ frame.area(),
+ &active_state.sessions,
+ 0,
+ true,
+ active_state.snapshot_at,
+ )
});
let sessions_text = buffer_text(&sessions);
assert!(sessions_text.contains("Provider"));
@@ -2365,7 +2446,7 @@ mod tests {
})
.collect::<Vec<_>>();
let session_buffer = draw(120, 6, |frame| {
- render_sessions(frame, frame.area(), &sessions, 11, true)
+ render_sessions(frame, frame.area(), &sessions, 11, true, state.snapshot_at)
});
let session_text = buffer_text(&session_buffer);
assert!(session_text.contains("row-0011"), "{session_text}");
diff --git a/tests/remote_monitor.rs b/tests/remote_monitor.rs
index a8a106f..2e79566 100644
--- a/tests/remote_monitor.rs
+++ b/tests/remote_monitor.rs
@@ -5,7 +5,7 @@ use std::{
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
- time::Duration,
+ time::{Duration, SystemTime},
};
use axum::{
@@ -187,6 +187,7 @@ async fn wait_until(mut predicate: impl FnMut() -> bool) {
async fn polling_keeps_last_snapshot_on_failure_and_recovers() {
let failing = Arc::new(AtomicBool::new(false));
let requests = Arc::new(AtomicUsize::new(0));
+ let snapshot_at = SystemTime::UNIX_EPOCH + Duration::from_secs(10_000);
let monitor = MonitorHandle::default();
monitor.request_started("r1", None, None, EndpointKind::Messages);
let server = serve(Router::new().route(
@@ -198,7 +199,8 @@ async fn polling_keeps_last_snapshot_on_failure_and_recovers() {
move || {
let failed = failing.load(Ordering::SeqCst);
requests.fetch_add(1, Ordering::SeqCst);
- let snapshot = MonitorResponse::from(monitor.snapshot());
+ let mut snapshot = MonitorResponse::from(monitor.snapshot());
+ snapshot.snapshot.snapshot_at = snapshot_at;
async move {
if failed {
StatusCode::SERVICE_UNAVAILABLE.into_response()
@@ -213,9 +215,11 @@ async fn polling_keeps_last_snapshot_on_failure_and_recovers() {
let remote = RemoteMonitor::connect(client(), server.url.clone())
.await
.unwrap();
+ assert_eq!(remote.snapshot().snapshot().snapshot_at, snapshot_at);
failing.store(true, Ordering::SeqCst);
wait_until(|| remote.snapshot().connection_error().is_some()).await;
assert_eq!(remote.snapshot().snapshot().active[0].request_id, "r1");
+ assert_eq!(remote.snapshot().snapshot().snapshot_at, snapshot_at);
monitor.request_completed("r1", 200, Some(10), Some(5));
failing.store(false, Ordering::SeqCst);
wait_until(|| {