Files
codex/codex-rs/windows-sandbox-rs/src/wfp_setup.rs
T
Charlie Marsh 548dd628df 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
2026-11-20 22:39:52 +00:00

184 lines
6.3 KiB
Rust

use crate::install_wfp_filters_for_account;
use crate::setup_error::sanitize_setup_metric_tag_value;
use anyhow::Result;
use codex_otel::OtelExporter;
use codex_otel::OtelProvider;
use codex_otel::OtelSettings;
use codex_otel::StatsigMetricsSettings;
use std::collections::BTreeMap;
use std::collections::HashMap;
use std::path::Path;
const WFP_SETUP_SERVICE_NAME: &str = "codex-windows-sandbox-setup";
const WFP_SETUP_SUCCESS_METRIC: &str = "codex.windows_sandbox.wfp_setup_success";
const WFP_SETUP_FAILURE_METRIC: &str = "codex.windows_sandbox.wfp_setup_failure";
#[derive(Debug, Clone, Copy)]
enum WfpSetupMetricOutcome {
Success,
Failure,
}
struct WfpSetupMetric {
outcome: WfpSetupMetricOutcome,
target_account: String,
installed_filter_count: usize,
error: Option<String>,
}
fn panic_payload_to_string(panic_payload: Box<dyn std::any::Any + Send>) -> String {
match panic_payload.downcast::<String>() {
Ok(message) => *message,
Err(panic_payload) => match panic_payload.downcast::<&'static str>() {
Ok(message) => (*message).to_string(),
Err(_) => "unknown panic payload".to_string(),
},
}
}
fn build_wfp_metrics_provider(
codex_home: &Path,
otel: Option<&StatsigMetricsSettings>,
) -> Result<Option<OtelProvider>> {
let Some(otel) = otel else {
return Ok(None);
};
// The setup helper cannot call codex-core's OTEL builder because core
// 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_http_metrics(&OtelSettings {
headers_helper: None,
http_client_factory: codex_http_client::HttpClientFactory::new(
codex_http_client::OutboundProxyPolicy::ReqwestDefault,
),
environment: otel.environment.clone(),
service_name: WFP_SETUP_SERVICE_NAME.to_string(),
service_version: env!("CARGO_PKG_VERSION").to_string(),
codex_home: codex_home.to_path_buf(),
exporter: OtelExporter::None,
trace_exporter: OtelExporter::None,
metrics_exporter: OtelExporter::Statsig,
runtime_metrics: false,
span_attributes: HashMap::new(),
tracestate: BTreeMap::new(),
})
.map_err(|err| anyhow::anyhow!("failed to initialize WFP setup metrics provider: {err}"))
}
fn emit_wfp_setup_metric(
codex_home: &Path,
otel: Option<&StatsigMetricsSettings>,
metric: &WfpSetupMetric,
) -> Result<()> {
let Some(provider) = build_wfp_metrics_provider(codex_home, otel)? else {
return Ok(());
};
if let Some(metrics) = provider.metrics() {
let target_account = sanitize_setup_metric_tag_value(&metric.target_account);
match metric.outcome {
WfpSetupMetricOutcome::Success => {
let installed_filter_count = metric.installed_filter_count.to_string();
metrics.counter(
WFP_SETUP_SUCCESS_METRIC,
/*inc*/ 1,
&[
("target_account", target_account.as_str()),
("installed_filter_count", installed_filter_count.as_str()),
],
)?;
}
WfpSetupMetricOutcome::Failure => {
let mut tags = vec![("target_account", target_account.as_str())];
let error_tag = metric.error.as_deref().map(sanitize_setup_metric_tag_value);
if let Some(error) = error_tag.as_deref() {
tags.push(("message", error));
}
metrics.counter(WFP_SETUP_FAILURE_METRIC, /*inc*/ 1, &tags)?;
}
}
}
provider.shutdown();
Ok(())
}
fn emit_wfp_setup_metric_safely<F>(
codex_home: &Path,
otel: Option<&StatsigMetricsSettings>,
offline_username: &str,
metric: &WfpSetupMetric,
log: &mut F,
) where
F: FnMut(&str),
{
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
emit_wfp_setup_metric(codex_home, otel, metric)
}));
match result {
Ok(Ok(())) => {}
Ok(Err(err)) => log(&format!(
"failed to emit WFP setup metric for {offline_username}: {err}"
)),
Err(panic_payload) => {
let error = panic_payload_to_string(panic_payload);
log(&format!(
"WFP setup metric emission panicked for {offline_username}: {error}"
));
}
}
}
pub fn install_wfp_filters<F>(
codex_home: &Path,
offline_username: &str,
otel: Option<&StatsigMetricsSettings>,
mut log: F,
) -> Result<()>
where
F: FnMut(&str),
{
let metric = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
install_wfp_filters_for_account(offline_username)
})) {
Ok(Ok(installed_filter_count)) => {
log(&format!(
"WFP setup succeeded for {offline_username} with {installed_filter_count} installed filters"
));
WfpSetupMetric {
outcome: WfpSetupMetricOutcome::Success,
target_account: offline_username.to_string(),
installed_filter_count,
error: None,
}
}
Ok(Err(err)) => {
let error = err.to_string();
log(&format!("WFP setup failed for {offline_username}: {error}"));
WfpSetupMetric {
outcome: WfpSetupMetricOutcome::Failure,
target_account: offline_username.to_string(),
installed_filter_count: 0,
error: Some(error),
}
}
Err(panic_payload) => {
let error = panic_payload_to_string(panic_payload);
log(&format!(
"WFP setup panicked for {offline_username}: {error}"
));
WfpSetupMetric {
outcome: WfpSetupMetricOutcome::Failure,
target_account: offline_username.to_string(),
installed_filter_count: 0,
error: Some(format!("panic: {error}")),
}
}
};
emit_wfp_setup_metric_safely(codex_home, otel, offline_username, &metric, &mut log);
match metric.error {
Some(error) => Err(anyhow::anyhow!(error)),
None => Ok(()),
}
}