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,