Skip to content

armgit / codex

Public Imported from GitHub
0

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.lock
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.toml
index 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.rs
index 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 @@ where
let 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.rs
new file mode 100644
index 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);
+}