From 413b27501d45d7bb202dc0ea4b8867762304d018 Mon Sep 17 00:00:00 2001 From: Cooper Gamble Date: Tue, 10 Mar 2026 16:35:27 +0000 Subject: [PATCH] [core] simplify inline compaction metrics [ci changed_files] Co-authored-by: Codex --- codex-rs/core/src/codex.rs | 159 ++++++------------------------------- 1 file changed, 26 insertions(+), 133 deletions(-) diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index 9027760418..38b2be5e1d 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -5387,13 +5387,10 @@ pub(crate) async fn run_turn( // new user message are recorded. Estimate pending incoming items (context // diffs/full reinjection + user input) and trigger compaction preemptively // when they would push the thread over the compaction threshold. - let mut inline_compaction_trigger = match run_pre_sampling_compact(&sess, &turn_context).await { - Ok(trigger) => trigger, - Err(err) => { - error!("Failed to run pre-sampling compact: {err}"); - return None; - } - }; + if let Err(err) = run_pre_sampling_compact(&sess, &turn_context).await { + error!("Failed to run pre-sampling compact: {err}"); + return None; + } let skills_outcome = Some(turn_context.turn_skills.outcome.as_ref()); @@ -5690,18 +5687,17 @@ pub(crate) async fn run_turn( .await { Ok(sampling_request_output) => { - if let Some(trigger) = inline_compaction_trigger.take() { + if inline_server_side_compaction_threshold(&sess, &turn_context).is_some() { let result = if sampling_request_output.observed_server_side_compaction { "applied" } else { "skipped" }; - let extra_tags = if sampling_request_output.observed_server_side_compaction { - Vec::new() - } else { - vec![("reason", "threshold_not_reached")] - }; - record_compaction_metric(&sess, "server_side", trigger, result, &extra_tags); + sess.services.session_telemetry.counter( + "codex.inline_compaction", + 1, + &[("result", result)], + ); } let SamplingRequestResult { needs_follow_up, @@ -5727,31 +5723,15 @@ pub(crate) async fn run_turn( // as long as compaction works well in getting us way below the token limit, we shouldn't worry about being in an infinite loop. if token_limit_reached && needs_follow_up { if inline_server_side_compaction_threshold(&sess, &turn_context).is_some() { - record_compaction_metric( - &sess, - "server_side", - AutoCompactTrigger::AutoFollowUp, - "requested", - &[], - ); - inline_compaction_trigger = Some(AutoCompactTrigger::AutoFollowUp); - } else { - record_inline_compaction_skip( - &sess, - &turn_context, - AutoCompactTrigger::AutoFollowUp, - ); - if run_auto_compact( - &sess, - &turn_context, - InitialContextInjection::BeforeLastUserMessage, - AutoCompactTrigger::AutoFollowUp, - ) - .await - .is_err() - { - return None; - } + } else if run_auto_compact( + &sess, + &turn_context, + InitialContextInjection::BeforeLastUserMessage, + ) + .await + .is_err() + { + return None; } continue; } @@ -5904,23 +5884,6 @@ pub(crate) async fn run_turn( last_agent_message } -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -enum AutoCompactTrigger { - AutoPreTurn, - AutoFollowUp, - PreviousModelPreflight, -} - -impl AutoCompactTrigger { - fn as_str(self) -> &'static str { - match self { - AutoCompactTrigger::AutoPreTurn => "auto_preturn", - AutoCompactTrigger::AutoFollowUp => "auto_followup", - AutoCompactTrigger::PreviousModelPreflight => "previous_model_preflight", - } - } -} - fn build_server_side_compaction_replacement_history( compaction_item: ResponseItem, history_at_compaction: &[ResponseItem], @@ -5935,24 +5898,6 @@ fn build_server_side_compaction_replacement_history( replacement_history } -fn record_compaction_metric( - sess: &Session, - mode: &'static str, - trigger: AutoCompactTrigger, - result: &'static str, - extra_tags: &[(&'static str, &str)], -) { - let mut tags = vec![ - ("mode", mode), - ("trigger", trigger.as_str()), - ("result", result), - ]; - tags.extend_from_slice(extra_tags); - sess.services - .session_telemetry - .counter("codex.compaction", 1, &tags); -} - fn inline_server_side_compaction_threshold( sess: &Session, turn_context: &TurnContext, @@ -5969,37 +5914,10 @@ fn inline_server_side_compaction_threshold( turn_context.model_info.auto_compact_token_limit() } -fn record_inline_compaction_skip( - sess: &Session, - turn_context: &TurnContext, - trigger: AutoCompactTrigger, -) { - let reason = if !sess.enabled(Feature::ServerSideCompaction) { - "flag_off" - } else if !should_use_remote_compact_task(&turn_context.provider) { - "non_openai" - } else { - "not_eligible" - }; - debug!( - turn_id = %turn_context.sub_id, - trigger = trigger.as_str(), - reason, - "skipping inline server-side compaction" - ); - record_compaction_metric( - sess, - "server_side", - trigger, - "skipped", - &[("reason", reason)], - ); -} - async fn run_pre_sampling_compact( sess: &Arc, turn_context: &Arc, -) -> CodexResult> { +) -> CodexResult<()> { let total_usage_tokens_before_compaction = sess.get_total_token_usage().await; if maybe_run_previous_model_inline_compact( sess, @@ -6008,7 +5926,7 @@ async fn run_pre_sampling_compact( ) .await? { - return Ok(None); + return Ok(()); } let total_usage_tokens = sess.get_total_token_usage().await; let auto_compact_limit = turn_context @@ -6016,27 +5934,12 @@ async fn run_pre_sampling_compact( .auto_compact_token_limit() .unwrap_or(i64::MAX); // Compact if the total usage tokens are greater than or equal to the auto-compact limit. - if total_usage_tokens >= auto_compact_limit { - if inline_server_side_compaction_threshold(sess, turn_context).is_some() { - record_compaction_metric( - sess, - "server_side", - AutoCompactTrigger::AutoPreTurn, - "requested", - &[], - ); - return Ok(Some(AutoCompactTrigger::AutoPreTurn)); - } - record_inline_compaction_skip(sess, turn_context, AutoCompactTrigger::AutoPreTurn); - run_auto_compact( - sess, - turn_context, - InitialContextInjection::DoNotInject, - AutoCompactTrigger::AutoPreTurn, - ) - .await?; + if total_usage_tokens >= auto_compact_limit + && inline_server_side_compaction_threshold(sess, turn_context).is_none() + { + run_auto_compact(sess, turn_context, InitialContextInjection::DoNotInject).await?; } - Ok(None) + Ok(()) } /// Runs pre-sampling compaction against the previous model when switching to a smaller @@ -6073,18 +5976,10 @@ async fn maybe_run_previous_model_inline_compact( && previous_model_turn_context.model_info.slug != turn_context.model_info.slug && old_context_window > new_context_window; if should_run { - record_compaction_metric( - sess, - "client_side", - AutoCompactTrigger::PreviousModelPreflight, - "requested", - &[], - ); run_auto_compact( sess, &previous_model_turn_context, InitialContextInjection::DoNotInject, - AutoCompactTrigger::PreviousModelPreflight, ) .await?; return Ok(true); @@ -6096,7 +5991,6 @@ async fn run_auto_compact( sess: &Arc, turn_context: &Arc, initial_context_injection: InitialContextInjection, - trigger: AutoCompactTrigger, ) -> CodexResult<()> { if should_use_remote_compact_task(&turn_context.provider) { run_inline_remote_auto_compact_task( @@ -6113,7 +6007,6 @@ async fn run_auto_compact( ) .await?; } - record_compaction_metric(sess, "client_side", trigger, "applied", &[]); Ok(()) }