Lightweight coding agent that runs in your terminal
Rust
Add configuration and feature diagnostics to report metadata (#46501)
pakrym-oaif5b941c9107a
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 77275c7822..5b4aead69d 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -3453,6 +3453,7 @@ dependencies = ["mime_guess","pretty_assertions","sentry",+ "serde_json","tokio","tracing","tracing-subscriber",diff --git a/codex-rs/core/src/feedback_config.rs b/codex-rs/core/src/feedback_config.rsnew file mode 100644index 0000000000..dc6d997004--- /dev/null+++ b/codex-rs/core/src/feedback_config.rs@@ -0,0 +1,81 @@+//! Searchable usage diagnostics from an explicit scalar-only configuration allowlist.+//! Never include prompts, paths, credentials, provider endpoints, or raw configuration.++use crate::config::Config;+use codex_features::FEATURES;+use codex_features::Feature;+use codex_features::Features;+use codex_protocol::openai_models::ModelInfo;+use serde_json::Value;+use serde_json::json;+use std::collections::BTreeMap;++pub(crate) fn usage_tags(+ config: &Config,+ features: &Features,+ model_info: &ModelInfo,+ service_tier: Option<&str>,+) -> BTreeMap<String, String> {+ // Keep configured overrides separate from the step's resolved model limits.+ // An explicit "unset" overwrites a prior turn's override in the collector.+ let values = json!({+ "model_context_window": config.model_context_window,+ "model_context_window_override": config.model_context_window.is_some(),+ "model_context_window_effective": model_info.usable_context_window(),+ "model_auto_compact_token_limit": config.model_auto_compact_token_limit,+ "model_auto_compact_token_limit_scope": config.model_auto_compact_token_limit_scope,+ "tool_output_token_limit": config.tool_output_token_limit,+ "project_doc_max_bytes": config.project_doc_max_bytes,+ "model_verbosity": config.model_verbosity,+ "model_reasoning_summary": config.model_reasoning_summary,+ "service_tier": service_tier,+ "review_model": config.review_model,+ "agent_default_subagent_model": config.agent_default_subagent_model,+ "agent_default_subagent_reasoning_effort": config.agent_default_subagent_reasoning_effort,+ "multi_agent_v2.max_concurrent_threads_per_session": config.multi_agent_v2.max_concurrent_threads_per_session,+ "multi_agent_v2.wait_agent_enabled": config.multi_agent_v2.wait_agent_enabled,+ "max_goal_token_budget": config.max_goal_token_budget,+ "memories.generate_memories": config.memories.generate_memories,+ "memories.use_memories": config.memories.use_memories,+ "memories.max_rollouts_per_startup": config.memories.max_rollouts_per_startup,+ "memories.max_raw_memories_for_consolidation": config.memories.max_raw_memories_for_consolidation,+ "memories.extract_model": config.memories.extract_model,+ "memories.consolidation_model": config.memories.consolidation_model,+ "token_budget.present": config.token_budget.is_some(),+ "token_budget.reminder_threshold_tokens": config.token_budget.as_ref().and_then(|budget| budget.reminder_threshold_tokens),+ "token_budget.auto_compact_fallback_buffer_tokens": config.token_budget.as_ref().and_then(|budget| budget.auto_compact_fallback_buffer_tokens),+ "rollout_budget.limit_tokens": config.rollout_budget.as_ref().map(|budget| budget.limit_tokens),+ "rollout_budget.sampling_token_weight": config.rollout_budget.as_ref().map(|budget| budget.sampling_token_weight),+ "rollout_budget.prefill_token_weight": config.rollout_budget.as_ref().map(|budget| budget.prefill_token_weight),+ });+ let Value::Object(values) = values else {+ unreachable!("the usage tag allowlist is an object");+ };+ let mut tags: BTreeMap<_, _> = values+ .into_iter()+ .map(|(key, value)| {+ let value = match value {+ Value::Null => "unset".to_string(),+ Value::String(value) => value,+ value => value.to_string(),+ };+ (key, value)+ })+ .collect();+ tags.extend(+ FEATURES+ .iter()+ .filter(|spec| !matches!(spec.id, Feature::Collab | Feature::SpawnCsv))+ .map(|spec| {+ (+ format!("feature.{}", spec.key),+ features.enabled(spec.id).to_string(),+ )+ }),+ );+ tags+}++#[cfg(test)]+#[path = "feedback_config_tests.rs"]+mod tests;diff --git a/codex-rs/core/src/feedback_config_tests.rs b/codex-rs/core/src/feedback_config_tests.rsnew file mode 100644index 0000000000..c56c61610e--- /dev/null+++ b/codex-rs/core/src/feedback_config_tests.rs@@ -0,0 +1,78 @@+//! Check configuration changes and feature toggles are represented without stale overrides.++use super::*;+use codex_models_manager::model_info::model_info_from_slug;+use codex_models_manager::model_info::with_config_overrides;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn configured_and_effective_context_are_distinct_and_unset_is_explicit() {+ let mut config = crate::config::test_config().await;+ config.model_context_window = Some(872_000);+ let mut model = model_info_from_slug("test-model");+ model.context_window = Some(272_000);+ model.max_context_window = Some(400_000);+ model.effective_context_window_percent = 95;+ let resolved = with_config_overrides(model.clone(), &config.to_models_manager_config());+ let tags = usage_tags(&config, &config.features, &resolved, Some("priority"));+ assert_eq!(+ [+ tags["model_context_window"].as_str(),+ tags["model_context_window_override"].as_str(),+ tags["model_context_window_effective"].as_str(),+ tags["service_tier"].as_str(),+ ],+ ["872000", "true", "380000", "priority"]+ );++ config.model_context_window = None;+ let mut updated = tags;+ updated.extend(usage_tags(+ &config,+ &config.features,+ &model,+ /*service_tier*/ None,+ ));+ assert_eq!(+ [+ updated["model_context_window"].as_str(),+ updated["model_context_window_override"].as_str(),+ updated["model_context_window_effective"].as_str(),+ updated["service_tier"].as_str(),+ ],+ ["unset", "false", "258400", "unset"]+ );+}++#[tokio::test]+async fn reported_features_have_boolean_tags_that_change_with_their_state() {+ let config = crate::config::test_config().await;+ let model = model_info_from_slug("test-model");+ let mut features = Features::with_defaults();+ for spec in FEATURES {+ features.disable(spec.id);+ }+ let disabled = usage_tags(&config, &features, &model, /*service_tier*/ None);+ for spec in FEATURES {+ features.enable(spec.id);+ }+ let enabled = usage_tags(&config, &features, &model, /*service_tier*/ None);+ let actual: BTreeMap<_, _> = disabled+ .iter()+ .filter(|(key, _)| key.starts_with("feature."))+ .map(|(key, value)| (key.as_str(), (value.as_str(), enabled[key].as_str())))+ .collect();+ let mut expected: BTreeMap<_, _> = FEATURES+ .iter()+ .map(|spec| (format!("feature.{}", spec.key), ("false", "true")))+ .collect();+ expected.remove("feature.multi_agent");+ expected.remove("feature.enable_fanout");+ assert_eq!(+ actual,+ expected+ .iter()+ .map(|(key, value)| (key.as_str(), *value))+ .collect()+ );+}diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rsindex b5d16bb817..c30987fef3 100644--- a/codex-rs/core/src/lib.rs+++ b/codex-rs/core/src/lib.rs@@ -188,6 +188,7 @@ pub use rollout::parse_cursor;pub use rollout::read_head_for_summary;pub use rollout::read_session_meta_line;pub use rollout::rollout_date_parts;+mod feedback_config;mod function_tool;mod state;mod tasks;diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex 7cf23d560d..7b624d8509 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -2436,7 +2436,12 @@ async fn try_run_sampling_request(sandbox_policy = &turn_context.sandbox_policy(),effort = step_context.settings.reasoning_effort(),auth_mode = sess.services.auth_manager.auth_mode(),- features = sess.features.enabled_features(),+ tags_json = tracing::field::display(serde_json::json!(crate::feedback_config::usage_tags(+ &turn_context.config,+ &sess.features,+ &step_context.settings.model_info,+ step_context.settings.service_tier.as_deref(),+ ))),);let inference_trace = sess.services.rollout_thread_trace.inference_trace_context(turn_context.sub_id.as_str(),diff --git a/codex-rs/feedback/Cargo.toml b/codex-rs/feedback/Cargo.tomlindex 2fa8d1f118..0f4cf40a17 100644--- a/codex-rs/feedback/Cargo.toml+++ b/codex-rs/feedback/Cargo.toml@@ -19,6 +19,7 @@ http = { workspace = true }httpdate = { workspace = true }mime_guess = { workspace = true }sentry = { version = "0.46" }+serde_json = { workspace = true }tokio = { workspace = true, features = ["time"] }tracing = { workspace = true }tracing-subscriber = { workspace = true }diff --git a/codex-rs/feedback/src/lib.rs b/codex-rs/feedback/src/lib.rsindex 2bf038d95f..3b5fec832b 100644--- a/codex-rs/feedback/src/lib.rs+++ b/codex-rs/feedback/src/lib.rs@@ -66,7 +66,8 @@ pub const MAX_ATTACHMENTS_BYTES: usize = 126 * 1024 * 1024;const MAX_DECODED_UPLOAD_BYTES: usize = 200 * 1024 * 1024;const MAX_EVENT_BYTES: usize = 1024 * 1024;const FEEDBACK_TAGS_TARGET: &str = "feedback_tags";-const MAX_FEEDBACK_TAGS: usize = 64;+// Leave room for every feature, usage settings, and request/auth diagnostics.+const MAX_FEEDBACK_TAGS: usize = 512;/// Structured request/auth fields that should be attached to feedback uploads.pub struct FeedbackRequestTags<'a> {@@ -818,6 +819,12 @@ wherelet mut visitor = FeedbackTagsVisitor::default();event.record(&mut visitor);+ // Expand runtime-selected keys alongside ordinary tracing fields.+ if let Some(json) = visitor.tags.remove("tags_json")+ && let Ok(tags) = serde_json::from_str::<BTreeMap<String, String>>(&json)+ {+ visitor.tags.extend(tags);+ }if visitor.tags.is_empty() {return;}@@ -870,6 +877,10 @@ impl Visit for FeedbackTagsVisitor {}}+#[cfg(test)]+#[path = "metadata_tests.rs"]+mod metadata_tests;+#[cfg(test)]#[path = "feedback_event_tests.rs"]mod feedback_event_tests;diff --git a/codex-rs/feedback/src/metadata_tests.rs b/codex-rs/feedback/src/metadata_tests.rsnew file mode 100644index 0000000000..583f560698--- /dev/null+++ b/codex-rs/feedback/src/metadata_tests.rs@@ -0,0 +1,77 @@+//! Exercise dynamic tag collection, upload serialization, and bounded updates.++use super::*;+use crate::CodexFeedback;+use pretty_assertions::assert_eq;+use sentry::protocol::Envelope;+use sentry::protocol::EnvelopeItem;+use tracing_subscriber::layer::SubscriberExt;+use tracing_subscriber::util::SubscriberInitExt;++#[test]+fn dynamic_tags_survive_upload_alongside_static_fields() {+ let feedback = CodexFeedback::new();+ let _guard = tracing_subscriber::registry()+ .with(feedback.metadata_layer())+ .set_default();+ let mut expected: BTreeMap<_, _> = (0..200)+ .map(|index| {+ (+ format!("feature.test_{index}"),+ (index % 2 == 0).to_string(),+ )+ })+ .collect();+ expected.insert("model_context_window".to_string(), "872000".to_string());+ tracing::info!(+ target: FEEDBACK_TAGS_TARGET,+ model = "test-model",+ tags_json = ?tracing::field::display(serde_json::json!(expected)),+ );+ expected.insert("model".to_string(), "test-model".to_string());+ let snapshot = feedback.snapshot(/*session_id*/ None);+ assert_eq!(snapshot.tags, expected);+ let event = snapshot.feedback_event(+ "bug", /*reason*/ None, /*tags*/ None, /*session_source*/ None,+ );+ expected.extend([+ ("thread_id".to_string(), snapshot.thread_id),+ ("classification".to_string(), "bug".to_string()),+ (+ "cli_version".to_string(),+ env!("CARGO_PKG_VERSION").to_string(),+ ),+ ]);+ assert_eq!(event.tags, expected);+ let mut envelope = Envelope::new();+ envelope.add_item(EnvelopeItem::Event(event));+ let (_, size) = crate::upload::encode_envelope(&envelope).unwrap();+ assert!(size < crate::MAX_EVENT_BYTES);+}++#[test]+fn bounded_dynamic_tags_still_update_existing_values() {+ let feedback = CodexFeedback::new();+ let _guard = tracing_subscriber::registry()+ .with(feedback.metadata_layer())+ .set_default();+ let mut expected: BTreeMap<_, _> = (0..MAX_FEEDBACK_TAGS)+ .map(|index| (format!("feature.test_{index}"), "false".to_string()))+ .collect();+ tracing::info!(target: FEEDBACK_TAGS_TARGET, tags_json = %serde_json::json!(expected));+ tracing::info!(+ target: FEEDBACK_TAGS_TARGET,+ tags_json = %serde_json::json!({+ "feature.overflow": "true",+ "feature.test_0": "true",+ }),+ );+ expected.insert("feature.test_0".to_string(), "true".to_string());+ assert_eq!(feedback.snapshot(/*session_id*/ None).tags, expected);+ tracing::info!(+ target: FEEDBACK_TAGS_TARGET,+ tags_json = %serde_json::json!({"feature.test_0": "false"}),+ );+ expected.insert("feature.test_0".to_string(), "false".to_string());+ assert_eq!(feedback.snapshot(/*session_id*/ None).tags, expected);+}