From 548dd628df95e01dbaee503ca9cbb216242baaf1 Mon Sep 17 00:00:00 2001 From: Charlie Marsh Date: Fri, 20 Nov 2026 22:03:40 +0000 Subject: [PATCH] Specialize OpenTelemetry providers for HTTP traces and metrics (#62854) ## Why The code-mode host exports traces over OTLP/HTTP, and the elevated Windows Filtering Platform setup helper exports Statsig metrics. Both used the general-purpose provider, which made exporter builders for unused signals and transports reachable from those binaries. ## What changed Add `OtelProvider::try_new_http_traces` for the code-mode host and `OtelProvider::try_new_http_metrics` for the Windows setup helper. Select exporter builders at compile time so each constructor reaches only the builders it needs. Both constructors reject unsupported signals and gRPC configuration. The metrics constructor also accepts Statsig. ## Testing Add unit tests for unsupported signals and gRPC configuration. Exercise the specialized constructors in the HTTP loopback tests for trace delivery on a current-thread Tokio runtime and cumulative metrics export. GitOrigin-RevId: 875916791f0176839764c51b5ab289d5dc45a4d2 --- codex-rs/code-mode-host/src/main.rs | 2 +- codex-rs/otel/src/metrics/client.rs | 15 +++- codex-rs/otel/src/provider.rs | 87 ++++++++++++++++--- .../otel/tests/suite/otlp_http_loopback.rs | 31 ++++--- codex-rs/windows-sandbox-rs/src/wfp_setup.rs | 2 +- 5 files changed, 112 insertions(+), 25 deletions(-) diff --git a/codex-rs/code-mode-host/src/main.rs b/codex-rs/code-mode-host/src/main.rs index 56d23db72f..3757f9b082 100644 --- a/codex-rs/code-mode-host/src/main.rs +++ b/codex-rs/code-mode-host/src/main.rs @@ -103,7 +103,7 @@ fn main() -> anyhow::Result<()> { } fn build_trace_provider(endpoint: &str) -> anyhow::Result { - OtelProvider::try_new(&OtelSettings { + OtelProvider::try_new_http_traces(&OtelSettings { headers_helper: None, http_client_factory: codex_http_client::HttpClientFactory::new( codex_http_client::OutboundProxyPolicy::ReqwestDefault, diff --git a/codex-rs/otel/src/metrics/client.rs b/codex-rs/otel/src/metrics/client.rs index c21a01db81..369b5824ed 100644 --- a/codex-rs/otel/src/metrics/client.rs +++ b/codex-rs/otel/src/metrics/client.rs @@ -350,6 +350,12 @@ pub struct MetricsClient { impl MetricsClient { /// Build a metrics client from configuration and validate defaults. pub fn new(config: MetricsConfig) -> Result { + Self::new_with_transport::(config) + } + + pub(crate) fn new_with_transport( + config: MetricsConfig, + ) -> Result { let MetricsConfig { headers_helper, http_client_factory, @@ -400,7 +406,7 @@ impl MetricsClient { .as_deref(), ); let exporter = crate::network_policy::PolicyExporter { - exporter: build_otlp_metric_exporter( + exporter: build_otlp_metric_exporter::( exporter, temporality, &http_client_factory, @@ -662,7 +668,7 @@ fn otlp_metrics_temporality(exporter: &OtelExporter, preference: Option<&str>) - } } -fn build_otlp_metric_exporter( +fn build_otlp_metric_exporter( exporter: OtelExporter, temporality: Temporality, factory: &codex_http_client::HttpClientFactory, @@ -682,7 +688,7 @@ fn build_otlp_metric_exporter( .into_iter() .all(|key| std::env::var_os(key).is_none()) .then_some(Compression::Zstd); - build_otlp_metric_exporter( + build_otlp_metric_exporter::( crate::config::resolve_exporter(&OtelExporter::Statsig), temporality, factory, @@ -690,6 +696,9 @@ fn build_otlp_metric_exporter( compression, ) } + OtelExporter::OtlpGrpc { .. } if !ALLOW_GRPC => Err(MetricsError::InvalidConfig { + message: "this provider requires OTLP/HTTP for metrics".into(), + }), OtelExporter::OtlpGrpc { endpoint, headers, diff --git a/codex-rs/otel/src/provider.rs b/codex-rs/otel/src/provider.rs index b0f81b0ba8..a57ed2672b 100644 --- a/codex-rs/otel/src/provider.rs +++ b/codex-rs/otel/src/provider.rs @@ -200,10 +200,47 @@ impl OtelProvider { } pub fn try_new(settings: &OtelSettings) -> Result, Box> { - let log_enabled = !matches!(settings.exporter, OtelExporter::None); - let trace_enabled = !matches!(settings.trace_exporter, OtelExporter::None); - let metric_exporter = crate::config::resolve_exporter(&settings.metrics_exporter); - let metrics_enabled = !matches!(metric_exporter, OtelExporter::None); + Self::try_new_with_exporters::(settings) + } + + /// Builds a provider for traces over OTLP/HTTP. + /// Returns an error if any other signal or transport is configured. + pub fn try_new_http_traces(settings: &OtelSettings) -> Result, Box> { + Self::try_new_with_exporters::(settings) + } + + /// Builds a provider for metrics over OTLP/HTTP, including Statsig. + /// Returns an error if any other signal or transport is configured. + pub fn try_new_http_metrics(settings: &OtelSettings) -> Result, Box> { + Self::try_new_with_exporters::(settings) + } + + /// Selects the reachable exporter builders at compile time while sharing setup and shutdown. + fn try_new_with_exporters< + const ALL_EXPORTERS: bool, + const HTTP_TRACES: bool, + const HTTP_METRICS: bool, + >( + settings: &OtelSettings, + ) -> Result, Box> { + let supports_traces = ALL_EXPORTERS || HTTP_TRACES; + let supports_metrics = ALL_EXPORTERS || HTTP_METRICS; + let log_configured = !matches!(settings.exporter, OtelExporter::None); + let trace_configured = !matches!(settings.trace_exporter, OtelExporter::None); + if (!ALL_EXPORTERS && log_configured) + || (!supports_traces && trace_configured) + || (!supports_metrics && !matches!(settings.metrics_exporter, OtelExporter::None)) + { + return Err("configured exporter is not supported by this provider".into()); + } + + let log_enabled = ALL_EXPORTERS && log_configured; + let trace_enabled = supports_traces && trace_configured; + let metrics_enabled = supports_metrics + && !matches!( + crate::config::resolve_exporter(&settings.metrics_exporter), + OtelExporter::None + ); if !log_enabled && !trace_enabled && !metrics_enabled { // Tracestate propagation is process-global; clear it when these @@ -251,9 +288,7 @@ impl OtelProvider { }) .transpose()?; - let metrics = if matches!(metric_exporter, OtelExporter::None) { - None - } else { + let metrics = if metrics_enabled { let mut config = MetricsConfig::otlp( settings.environment.clone(), settings.service_name.clone(), @@ -267,7 +302,9 @@ impl OtelProvider { if settings.runtime_metrics { config = config.with_runtime_reader(); } - Some(MetricsClient::new(config)?) + Some(MetricsClient::new_with_transport::(config)?) + } else { + None }; let log_resource = make_resource(settings, ResourceKind::Logs); @@ -285,7 +322,7 @@ impl OtelProvider { let tracer_provider = trace_enabled .then(|| { - build_tracer_provider( + build_tracer_provider::( &trace_resource, &settings.trace_exporter, settings.span_attributes.clone(), @@ -577,7 +614,7 @@ fn build_logger( Ok(builder.build()) } -fn build_tracer_provider( +fn build_tracer_provider( resource: &Resource, exporter: &OtelExporter, span_attributes: HashMap, @@ -589,6 +626,9 @@ fn build_tracer_provider( let span_exporter = match crate::config::resolve_exporter(exporter) { OtelExporter::None => return Ok(tracer_provider_builder(resource, span_attributes).build()), OtelExporter::Statsig => unreachable!("statsig exporter should be resolved"), + OtelExporter::OtlpGrpc { .. } if !ALLOW_GRPC => { + return Err("this provider requires OTLP/HTTP for traces".into()); + } OtelExporter::OtlpGrpc { endpoint, headers, @@ -925,6 +965,33 @@ mod tests { Ok(()) } + #[test] + fn restricted_providers_reject_unsupported_signals() { + let mut settings = test_otel_settings(); + settings.metrics_exporter = OtelExporter::Statsig; + assert!(OtelProvider::try_new_http_traces(&settings).is_err()); + + settings = test_otel_settings(); + settings.trace_exporter = OtelExporter::Statsig; + assert!(OtelProvider::try_new_http_metrics(&settings).is_err()); + } + + #[test] + fn http_providers_reject_grpc_for_their_supported_signal() { + let grpc = OtelExporter::OtlpGrpc { + endpoint: "http://127.0.0.1:4317".to_string(), + headers: HashMap::new(), + tls: None, + }; + let mut settings = test_otel_settings(); + settings.trace_exporter = grpc.clone(); + assert!(OtelProvider::try_new_http_traces(&settings).is_err()); + + settings = test_otel_settings(); + settings.metrics_exporter = grpc; + assert!(OtelProvider::try_new_http_metrics(&settings).is_err()); + } + fn test_otel_settings() -> OtelSettings { OtelSettings { headers_helper: None, diff --git a/codex-rs/otel/tests/suite/otlp_http_loopback.rs b/codex-rs/otel/tests/suite/otlp_http_loopback.rs index d7df8a5874..e8f92ffde9 100644 --- a/codex-rs/otel/tests/suite/otlp_http_loopback.rs +++ b/codex-rs/otel/tests/suite/otlp_http_loopback.rs @@ -1,8 +1,6 @@ use codex_http_client::HttpClientFactory; use codex_http_client::OutboundProxyPolicy; use codex_otel::EXEC_SERVER_CLIENT_REQUEST_COUNT_METRIC; -use codex_otel::MetricsClient; -use codex_otel::MetricsConfig; use codex_otel::OtelExporter; use codex_otel::OtelHttpProtocol; use codex_otel::OtelProvider; @@ -208,17 +206,30 @@ fn otlp_http_exporter_honors_cumulative_temporality_env() -> Result<()> { let _ = tx.send(captured); }); - let metrics = MetricsClient::new(MetricsConfig::otlp( - "test", - "codex-cli", - env!("CARGO_PKG_VERSION"), - OtelExporter::OtlpHttp { + let provider = OtelProvider::try_new_http_metrics(&OtelSettings { + http_client_factory: HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault), + environment: "test".to_string(), + service_name: "codex-cli".to_string(), + service_version: env!("CARGO_PKG_VERSION").to_string(), + codex_home: PathBuf::from("."), + headers_helper: None, + exporter: OtelExporter::None, + trace_exporter: OtelExporter::None, + metrics_exporter: OtelExporter::OtlpHttp { endpoint: format!("http://{addr}/v1/metrics"), headers: HashMap::new(), protocol: OtelHttpProtocol::Json, tls: None, }, - ))?; + runtime_metrics: false, + span_attributes: HashMap::new(), + tracestate: BTreeMap::new(), + }) + .expect("set up a metrics-only provider") + .expect("metrics enabled"); + assert!(provider.logger.is_none()); + assert!(provider.tracer_provider.is_none()); + let metrics = provider.metrics().expect("metrics client"); metrics.counter("codex.turns", /*inc*/ 1, &[("source", "test")])?; metrics.counter("codex.api_request", /*inc*/ 1, &[("status", "200")])?; @@ -266,7 +277,7 @@ fn otlp_http_exporter_honors_cumulative_temporality_env() -> Result<()> { /*value*/ 1, &[("component", "test")], )?; - metrics.shutdown()?; + provider.shutdown(); server.join().expect("server join"); let captured = rx.recv_timeout(Duration::from_secs(1)).expect("captured"); @@ -878,7 +889,7 @@ fn otlp_http_exporter_sends_traces_to_collector_in_current_thread_tokio_runtime( .expect("current-thread runtime"); let result = runtime.block_on(async move { - let otel = OtelProvider::try_new(&OtelSettings { + let otel = OtelProvider::try_new_http_traces(&OtelSettings { headers_helper: None, http_client_factory: HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault), environment: "test".to_string(), diff --git a/codex-rs/windows-sandbox-rs/src/wfp_setup.rs b/codex-rs/windows-sandbox-rs/src/wfp_setup.rs index 790e966a3d..bee113ddac 100644 --- a/codex-rs/windows-sandbox-rs/src/wfp_setup.rs +++ b/codex-rs/windows-sandbox-rs/src/wfp_setup.rs @@ -47,7 +47,7 @@ fn build_wfp_metrics_provider( // depends on this crate, so the parent process passes only the resolved // Statsig environment in the elevation payload. Other exporters are // intentionally omitted from this helper path. - OtelProvider::try_new(&OtelSettings { + OtelProvider::try_new_http_metrics(&OtelSettings { headers_helper: None, http_client_factory: codex_http_client::HttpClientFactory::new( codex_http_client::OutboundProxyPolicy::ReqwestDefault,