Record status line provider starts and failures (#62046)

## What changed

Add `codex.statusline.provider_started` and `codex.statusline.provider_failed` counters through the existing status line metrics collector. Classify failures with `kind=timeout` or `kind=error`, and ignore events from stale readers.

## Testing

Extend reader and picker tests to check counters for explicit selection, polling, invalid content, timeouts, restarts, and stale events.

GitOrigin-RevId: 8c3074743f3b31409ccd713edb228e4dce809ea8
This commit is contained in:
Joe Savona
2026-11-17 13:38:01 +00:00
committed by copyberry
parent efc5d35455
commit d75ea7b0fa
5 changed files with 96 additions and 15 deletions
+1 -1
View File
@@ -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);
@@ -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(())
}
@@ -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 {
@@ -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<UiTree, ReadIssue> {
let [
McpResourceContent::Text {
@@ -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<std::io::Result<RequestResult>>;
const URI: &str = "ui://fixture/status";
struct Reader {
collector: Collector,
app_config: Config,
metrics: StatuslineMetrics,
chat: ChatWidget,
owner: AppServerSession,
events: UnboundedReceiver<AppEvent>,
@@ -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"]
);
}