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
This commit is contained in:
Charlie Marsh
2026-11-20 22:39:52 +00:00
committed by copyberry
parent 63598243af
commit 548dd628df
5 changed files with 112 additions and 25 deletions
+1 -1
View File
@@ -103,7 +103,7 @@ fn main() -> anyhow::Result<()> {
}
fn build_trace_provider(endpoint: &str) -> anyhow::Result<OtelProvider> {
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,
+12 -3
View File
@@ -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> {
Self::new_with_transport::<true>(config)
}
pub(crate) fn new_with_transport<const ALLOW_GRPC: bool>(
config: MetricsConfig,
) -> Result<Self> {
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::<ALLOW_GRPC>(
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<const ALLOW_GRPC: bool>(
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::<ALLOW_GRPC>(
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,
+77 -10
View File
@@ -200,10 +200,47 @@ impl OtelProvider {
}
pub fn try_new(settings: &OtelSettings) -> Result<Option<Self>, Box<dyn Error>> {
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::<true, false, false>(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<Option<Self>, Box<dyn Error>> {
Self::try_new_with_exporters::<false, true, false>(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<Option<Self>, Box<dyn Error>> {
Self::try_new_with_exporters::<false, false, true>(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<Option<Self>, Box<dyn Error>> {
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::<ALL_EXPORTERS>(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::<ALL_EXPORTERS>(
&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<const ALLOW_GRPC: bool>(
resource: &Resource,
exporter: &OtelExporter,
span_attributes: HashMap<String, String>,
@@ -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,
+21 -10
View File
@@ -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(),
+1 -1
View File
@@ -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,