diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index dcd3793df9..b976c63d59 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -517,7 +517,7 @@ impl App { } AppEvent::StatuslinePicker { scan, updates } => self.finish_statusline_discovery(scan, updates, app_server), AppEvent::StatuslineRead(event) => { - self.chat_widget.handle_statusline_read(event, app_server); + self.chat_widget.handle_statusline_read(event, app_server, &self.statusline_metrics, &self.config); } AppEvent::TaskToolsAvailable { thread_id } => { app_server.remember_task_tool_thread(thread_id); diff --git a/codex-rs/tui/src/app/statusline_picker_tests.rs b/codex-rs/tui/src/app/statusline_picker_tests.rs index 82c8d6ee1b..61a5936c7b 100644 --- a/codex-rs/tui/src/app/statusline_picker_tests.rs +++ b/codex-rs/tui/src/app/statusline_picker_tests.rs @@ -223,14 +223,26 @@ async fn discovery_batch_keeps_the_highlight() -> anyhow::Result<()> { #[tokio::test(start_paused = true)] async fn discovery_only_starts_a_reader_on_explicit_selection() -> anyhow::Result<()> { - let (mut app, owner, _requests, mut events) = picker().await?; + let (mut app, mut owner, _requests, mut events) = picker().await?; + let mut tui = make_test_tui()?; + let collector = Collector::new(); + app.statusline_metrics = collector.metrics(&mut app.config); let thread = ThreadId::new(); let cwd = app.config.cwd.to_path_buf(); app.chat_widget .handle_thread_session(test_thread_session(thread, cwd)); let provider = advertised("work", "calendar", "ui://work/day"); - for uri in ["ui://work/day", "ui://work/replacement"] { + for (uri, expected) in [ + ( + "ui://work/day", + &[ + "provider_changed change=enabled_custom 1", + "provider_started 1", + ][..], + ), + ("ui://work/replacement", &["provider_started 1"][..]), + ] { app.open_statusline_picker(&owner); let scan = app.statusline_picker.as_ref().unwrap().id; let found = advertised("work", "calendar", uri); @@ -240,6 +252,7 @@ async fn discovery_only_starts_a_reader_on_explicit_selection() -> anyhow::Resul !std::iter::from_fn(|| events.try_recv().ok()) .any(|event| matches!(event, AppEvent::StatuslineRead(_))) ); + assert_eq!(collector.snapshot(), ["picker_opened 1"]); app.choose_statusline_provider( scan, Some(provider.id.clone()), @@ -247,10 +260,13 @@ async fn discovery_only_starts_a_reader_on_explicit_selection() -> anyhow::Resul &owner, ) .await; - assert!( - std::iter::from_fn(|| events.try_recv().ok()) - .any(|event| matches!(event, AppEvent::StatuslineRead(_))) - ); + let read = std::iter::from_fn(|| events.try_recv().ok()) + .find(|event| matches!(event, AppEvent::StatuslineRead(_))) + .expect("explicit choice starts a reader"); + crate::boxed_future!(app.handle_event(&mut tui, &mut owner, read)) + .await + .unwrap(); + assert_eq!(collector.snapshot(), expected); } Ok(()) } diff --git a/codex-rs/tui/src/chatwidget/statusline_reader.rs b/codex-rs/tui/src/chatwidget/statusline_reader.rs index d447ad7ec5..d2f083560e 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader.rs @@ -11,6 +11,8 @@ use crate::app_event::AppEvent; use crate::app_event_sender::AppEventSender; use crate::app_server_session::AppServerSession; use crate::backend_id::BackendId; +use crate::legacy_core::config::Config; +use crate::statusline_metrics::StatuslineMetrics; use crate::statusline_provider::LOOKUP_TIMEOUT; use crate::statusline_provider::ProviderId; use crate::statusline_provider::ProviderLookupError; @@ -171,6 +173,8 @@ impl ChatWidget { &mut self, event: StatuslineReadEvent, owner: &AppServerSession, + metrics: &StatuslineMetrics, + config: &Config, ) { let Some(footer) = self .statusline_read @@ -184,7 +188,10 @@ impl ChatWidget { return; } match event.step { - ReadStep::Start(ready) => footer.start(owner, &self.app_event_tx, ready), + ReadStep::Start(ready) => { + metrics.record(config, "codex.statusline.provider_started", &[]); + footer.start(owner, &self.app_event_tx, ready); + } ReadStep::Snapshot(backend, reply) => { if backend == owner.backend_id() && let Some(state) = self.statusline_state() @@ -199,6 +206,11 @@ impl ChatWidget { let tree = match result { Ok(tree) => tree, Err(failure) => { + metrics.record( + config, + "codex.statusline.provider_failed", + &[("kind", failure.metric_kind())], + ); footer.cancel.cancel(); tracing::warn!(?failure, "Status line provider stopped"); let message = match failure { diff --git a/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs b/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs index 1f7e28fa57..018aabf11e 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader/resource.rs @@ -46,6 +46,15 @@ pub(super) enum Failure { Read(#[from] ReadIssue), } +impl Failure { + pub(super) fn metric_kind(&self) -> &'static str { + match self { + Self::LookupTimedOut | Self::Read(ReadIssue::TimedOut) => "timeout", + Self::LookupUnavailable | Self::Snapshot | Self::Read(_) => "error", + } + } +} + pub(super) fn decode_tree(uri: &str, contents: &[McpResourceContent]) -> Result { let [ McpResourceContent::Text { diff --git a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs index ae588c819f..28479899d5 100644 --- a/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs +++ b/codex-rs/tui/src/chatwidget/statusline_reader_tests.rs @@ -6,6 +6,7 @@ use crate::app_server_session::ThreadParamsMode; use crate::bottom_pane::StatusLineFocus; use crate::chatwidget::tests::make_chatwidget_manual_with_sender; use crate::chatwidget::tests::render_bottom_popup; +use crate::statusline_metrics::tests::Collector; use codex_app_server_client::AppServerClient; use codex_app_server_client::CloudClient; use codex_app_server_client::CloudCommand; @@ -136,14 +137,22 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() token, step: ReadStep::Finished(server.backend_id(), Ok(UiTree(root))), }; - chat.handle_statusline_read(finish(token, Some(UiNode::String("Ready".into()))), &server); + let collector = Collector::new(); + let mut app_config = chat.config.clone(); + let metrics = collector.metrics(&mut app_config); + chat.handle_statusline_read( + finish(token, Some(UiNode::String("Ready".into()))), + &server, + &metrics, + &app_config, + ); chat.refresh_status_line(); let ready = footer(&chat).unwrap(); insta::assert_snapshot!(format!("{initializing}\n{ready}"), @" Initializing… Ready "); - chat.handle_statusline_read(finish(token, /*root*/ None), &server); + chat.handle_statusline_read(finish(token, /*root*/ None), &server, &metrics, &app_config); chat.refresh_status_line(); assert_eq!(footer(&chat).as_deref(), Some("")); assert!(!render_bottom_popup(&chat, /*width*/ 80).contains("native-agent-label")); @@ -156,7 +165,7 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() chat.read_only_history = false; chat.refresh_status_line(); let [resumed] = read_events(&mut rx).try_into().unwrap(); - chat.handle_statusline_read(finish(token, /*root*/ None), &server); + chat.handle_statusline_read(finish(token, /*root*/ None), &server, &metrics, &app_config); assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); let token = resumed.token; chat.primary_environment_cwd = Some(crate::session_state::EnvironmentCwd { @@ -173,6 +182,8 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() step: ReadStep::Snapshot(server.backend_id(), reply), }, &server, + &metrics, + &app_config, ); assert!(snapshot.await.is_err()); let [replacement] = read_events(&mut rx).try_into().unwrap(); @@ -183,14 +194,20 @@ async fn statusline_reader_waits_for_the_displayed_thread_and_keeps_its_result() chat.handle_statusline_read( finish(token, Some(UiNode::String("retired".into()))), &server, + &metrics, + &app_config, ); assert_eq!(footer(&chat).as_deref(), Some("Initializing…")); + assert!(collector.snapshot().is_empty()); } type Reply = oneshot::Sender>; const URI: &str = "ui://fixture/status"; struct Reader { + collector: Collector, + app_config: Config, + metrics: StatuslineMetrics, chat: ChatWidget, owner: AppServerSession, events: UnboundedReceiver, @@ -214,7 +231,13 @@ impl Reader { tool: "line".into(), }))); chat.refresh_status_line(); + let collector = Collector::new(); + let mut app_config = chat.config.clone(); + let metrics = collector.metrics(&mut app_config); let mut reader = Self { + collector, + app_config, + metrics, chat, owner, events, @@ -224,10 +247,15 @@ impl Reader { reader } + fn handle(&mut self, event: StatuslineReadEvent) { + self.chat + .handle_statusline_read(event, &self.owner, &self.metrics, &self.app_config); + } + async fn dispatch(&mut self) { while let Some(event) = self.events.recv().await { if let AppEvent::StatuslineRead(event) = event { - self.chat.handle_statusline_read(event, &self.owner); + self.handle(event); return; } } @@ -348,6 +376,7 @@ async fn statusline_polls_one_second_after_completion_including_empty_content() advance(/*millis*/ 1).await; let _third = reader.read(URI).await; assert_eq!(completed.elapsed(), Duration::from_secs(1)); + assert_eq!(reader.collector.snapshot(), ["provider_started 1"]); } #[tokio::test(start_paused = true)] @@ -369,6 +398,10 @@ async fn statusline_invalid_content_stops_polling_immediately() { reader.chat.refresh_status_line(); advance(/*millis*/ 60_000).await; reader.assert_idle(); + assert_eq!( + reader.collector.snapshot(), + ["provider_failed kind=error 1", "provider_started 1"] + ); } #[tokio::test(start_paused = true)] @@ -466,6 +499,10 @@ async fn statusline_hung_read_stops_polling_after_one_second() { reader.chat.refresh_status_line(); advance(/*millis*/ 60_000).await; reader.assert_idle(); + assert_eq!( + reader.collector.snapshot(), + ["provider_failed kind=timeout 1", "provider_started 1"] + ); } #[tokio::test(start_paused = true)] @@ -488,6 +525,10 @@ async fn statusline_startup_timeout_stops_before_the_first_read() { reader.chat.refresh_status_line(); advance(/*millis*/ 60_000).await; reader.assert_idle(); + assert_eq!( + reader.collector.snapshot(), + ["provider_failed kind=timeout 1", "provider_started 1"] + ); } #[tokio::test(start_paused = true)] @@ -562,13 +603,12 @@ async fn statusline_changing_provider_or_reconnecting_discards_the_previous_read held.closed().await; for result in [Ok(UiTree(None)), Err(Failure::Snapshot)] { let step = ReadStep::Finished(reader.owner.backend_id(), result); - reader - .chat - .handle_statusline_read(StatuslineReadEvent { token: old, step }, &reader.owner); + reader.handle(StatuslineReadEvent { token: old, step }); } assert_eq!(footer(&reader.chat).as_deref(), Some("Initializing…")); held = next; } + assert_eq!(reader.collector.snapshot(), ["provider_started 3"]); } #[tokio::test(start_paused = true)] @@ -600,4 +640,8 @@ async fn statusline_explicit_reselection_restarts_a_failed_reader() { respond(reader.read(URI).await, r#""restored""#); reader.dispatch().await; assert_eq!(footer(&reader.chat).as_deref(), Some("restored")); + assert_eq!( + reader.collector.snapshot(), + ["provider_failed kind=timeout 1", "provider_started 2"] + ); }