Upgrade OTEL and remove support for Jaeger and Zipkin exporters

Cargo.toml

@@ -55,6 +55,10 @@ mas-templates = { path = "./crates/templates/", version = "=0.8.0" }
 mas-tower = { path = "./crates/tower/", version = "=0.8.0" }
 oauth2-types = { path = "./crates/oauth2-types/", version = "=0.8.0" }
 
+# Utility to write and implement async traits
+[workspace.dependencies.async-trait]
+version = "0.1.77"
+
 # High-level error handling
 [workspace.dependencies.anyhow]
 version = "1.0.79"
@@ -132,12 +136,15 @@ version = "0.3.18"
 
 # OpenTelemetry
 [workspace.dependencies.opentelemetry]
-version = "0.21.0"
+version = "0.22.0"
 features = ["trace", "metrics"]
+[workspace.dependencies.opentelemetry-http]
+version = "0.11.0"
+features = ["hyper", "tokio"]
 [workspace.dependencies.opentelemetry-semantic-conventions]
-version = "0.13.0"
+version = "0.14.0"
 [workspace.dependencies.tracing-opentelemetry]
-version = "0.22.0"
+version = "0.23.0"
 default-features = false
 
 # URL manipulation

crates/axum-utils/Cargo.toml

@@ -12,7 +12,7 @@ publish = false
 workspace = true
 
 [dependencies]
-async-trait = "0.1.77"
+async-trait.workspace = true
 axum = { version = "0.6.20", features = ["headers"] }
 axum-extra = { version = "0.8.0", features = ["cookie-private", "cookie-key-expansion"] }
 chrono.workspace = true

crates/cli/Cargo.toml

@@ -39,14 +39,13 @@ tracing-appender = "0.2.3"
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 tracing-opentelemetry.workspace = true
 opentelemetry.workspace = true
-opentelemetry-http = { version = "0.10.0", features = ["tokio", "hyper"] }
-opentelemetry-jaeger = { version = "0.20.0", features = ["rt-tokio", "collector_client"] }
-opentelemetry-otlp = { version = "0.14.0", features = ["trace", "metrics"] }
-opentelemetry-prometheus = "0.14.1"
+opentelemetry-http.workspace = true
+opentelemetry-jaeger-propagator = "0.1.0"
+opentelemetry-otlp = { version = "0.15.0", default-features = false, features = ["trace", "metrics", "http-proto"] }
+opentelemetry-prometheus = "0.15.0"
 opentelemetry-semantic-conventions.workspace = true
-opentelemetry-stdout = { version = "0.2.0", features = ["trace", "metrics"] }
-opentelemetry_sdk = { version = "0.21.2", features = ["trace", "metrics", "rt-tokio"] }
-opentelemetry-zipkin = { version = "0.19.0", default-features = false }
+opentelemetry-stdout = { version = "0.3.0", features = ["trace", "metrics"] }
+opentelemetry_sdk = { version = "0.22.1", features = ["trace", "metrics", "rt-tokio"] }
 prometheus = "0.13.3"
 sentry = { version = "0.31.8", default-features = false, features = ["backtrace", "contexts", "panic", "tower"] }
 sentry-tracing = "0.31.8"

crates/cli/src/server.rs

@@ -160,16 +160,22 @@ fn make_http_span<B>(req: &Request<B>) -> Span {
 
 fn on_http_request_labels<B>(request: &Request<B>) -> Vec<KeyValue> {
     vec![
-        NETWORK_PROTOCOL_NAME.string("http"),
-        NETWORK_PROTOCOL_VERSION.string(otel_net_protocol_version(request)),
-        HTTP_REQUEST_METHOD.string(otel_http_method(request)),
-        HTTP_ROUTE.string(otel_http_route(request).unwrap_or("FALLBACK").to_owned()),
-        URL_SCHEME.string(otel_url_scheme(request).as_ref()),
+        KeyValue::new(NETWORK_PROTOCOL_NAME, "http"),
+        KeyValue::new(NETWORK_PROTOCOL_VERSION, otel_net_protocol_version(request)),
+        KeyValue::new(HTTP_REQUEST_METHOD, otel_http_method(request)),
+        KeyValue::new(
+            HTTP_ROUTE,
+            otel_http_route(request).unwrap_or("FALLBACK").to_owned(),
+        ),
+        KeyValue::new(URL_SCHEME, otel_url_scheme(request)),
     ]
 }
 
 fn on_http_response_labels<B>(res: &Response<B>) -> Vec<KeyValue> {
-    vec![HTTP_RESPONSE_STATUS_CODE.i64(res.status().as_u16().into())]
+    vec![KeyValue::new(
+        HTTP_RESPONSE_STATUS_CODE,
+        i64::from(res.status().as_u16()),
+    )]
 }
 
 pub fn build_router<B>(

crates/cli/src/telemetry.rs

@@ -16,31 +16,31 @@ use std::time::Duration;
 
 use anyhow::Context as _;
 use hyper::{header::CONTENT_TYPE, Body, Response};
-use mas_config::{
-    JaegerExporterProtocolConfig, MetricsExporterConfig, Propagator, TelemetryConfig,
-    TracingExporterConfig,
+use mas_config::{MetricsExporterConfig, Propagator, TelemetryConfig, TracingExporterConfig};
+use opentelemetry::{
+    global,
+    propagation::{TextMapCompositePropagator, TextMapPropagator},
+    trace::TracerProvider as _,
+    KeyValue,
 };
-use opentelemetry::{global, propagation::TextMapPropagator, trace::TracerProvider as _};
-use opentelemetry_jaeger::Propagator as JaegerPropagator;
 use opentelemetry_otlp::MetricsExporterBuilder;
 use opentelemetry_prometheus::PrometheusExporter;
 use opentelemetry_sdk::{
     self,
     metrics::{
         reader::{DefaultAggregationSelector, DefaultTemporalitySelector},
-        ManualReader, MeterProvider, PeriodicReader,
+        ManualReader, PeriodicReader, SdkMeterProvider,
     },
-    propagation::{BaggagePropagator, TextMapCompositePropagator, TraceContextPropagator},
+    propagation::{BaggagePropagator, TraceContextPropagator},
     trace::{Sampler, Tracer, TracerProvider},
     Resource,
 };
 use opentelemetry_semantic_conventions as semcov;
-use opentelemetry_zipkin::{B3Encoding, Propagator as ZipkinPropagator};
 use prometheus::Registry;
 use tokio::sync::OnceCell;
 use url::Url;
 
-static METER_PROVIDER: OnceCell<MeterProvider> = OnceCell::const_new();
+static METER_PROVIDER: OnceCell<SdkMeterProvider> = OnceCell::const_new();
 static PROMETHEUS_REGISTRY: OnceCell<Registry> = OnceCell::const_new();
 
 pub fn setup(config: &TelemetryConfig) -> anyhow::Result<Option<Tracer>> {
@@ -72,9 +72,7 @@ fn match_propagator(propagator: Propagator) -> Box<dyn TextMapPropagator + Send
     match propagator {
         P::TraceContext => Box::new(TraceContextPropagator::new()),
         P::Baggage => Box::new(BaggagePropagator::new()),
-        P::Jaeger => Box::new(JaegerPropagator::new()),
-        P::B3 => Box::new(ZipkinPropagator::with_encoding(B3Encoding::SingleHeader)),
-        P::B3Multi => Box::new(ZipkinPropagator::with_encoding(B3Encoding::MultipleHeader)),
+        P::Jaeger => Box::new(opentelemetry_jaeger_propagator::Propagator::new()),
     }
 }
 
@@ -99,7 +97,9 @@ fn stdout_tracer_provider() -> TracerProvider {
 fn otlp_tracer(endpoint: Option<&Url>) -> anyhow::Result<Tracer> {
     use opentelemetry_otlp::WithExportConfig;
 
-    let mut exporter = opentelemetry_otlp::new_exporter().tonic();
+    let mut exporter = opentelemetry_otlp::new_exporter()
+        .http()
+        .with_http_client(http_client());
     if let Some(endpoint) = endpoint {
         exporter = exporter.with_endpoint(endpoint.to_string());
     }
@@ -114,65 +114,6 @@ fn otlp_tracer(endpoint: Option<&Url>) -> anyhow::Result<Tracer> {
     Ok(tracer)
 }
 
-fn jaeger_agent_tracer_provider(host: &str, port: u16) -> anyhow::Result<TracerProvider> {
-    let pipeline = opentelemetry_jaeger::new_agent_pipeline()
-        .with_service_name(env!("CARGO_PKG_NAME"))
-        .with_trace_config(trace_config())
-        .with_endpoint(format!("{host}:{port}"));
-
-    let tracer_provider = pipeline
-        .build_batch(opentelemetry_sdk::runtime::Tokio)
-        .context("Failed to configure Jaeger agent exporter")?;
-
-    Ok(tracer_provider)
-}
-
-fn jaeger_collector_tracer_provider(
-    endpoint: &str,
-    username: Option<&str>,
-    password: Option<&str>,
-) -> anyhow::Result<TracerProvider> {
-    let http_client = http_client();
-    let mut pipeline = opentelemetry_jaeger::new_collector_pipeline()
-        .with_service_name(env!("CARGO_PKG_NAME"))
-        .with_trace_config(trace_config())
-        .with_http_client(http_client)
-        .with_endpoint(endpoint);
-
-    if let Some(username) = username {
-        pipeline = pipeline.with_username(username);
-    }
-
-    if let Some(password) = password {
-        pipeline = pipeline.with_password(password);
-    }
-
-    let tracer_provider = pipeline
-        .build_batch(opentelemetry_sdk::runtime::Tokio)
-        .context("Failed to configure Jaeger collector exporter")?;
-
-    Ok(tracer_provider)
-}
-
-fn zipkin_tracer(collector_endpoint: &Option<Url>) -> anyhow::Result<Tracer> {
-    let http_client = http_client();
-
-    let mut pipeline = opentelemetry_zipkin::new_pipeline()
-        .with_http_client(http_client)
-        .with_service_name(env!("CARGO_PKG_NAME"))
-        .with_trace_config(trace_config());
-
-    if let Some(collector_endpoint) = collector_endpoint {
-        pipeline = pipeline.with_collector_endpoint(collector_endpoint.as_str());
-    }
-
-    let tracer = pipeline
-        .install_batch(opentelemetry_sdk::runtime::Tokio)
-        .context("Failed to configure Zipkin exporter")?;
-
-    Ok(tracer)
-}
-
 fn tracer(config: &TracingExporterConfig) -> anyhow::Result<Option<Tracer>> {
     let tracer_provider = match config {
         TracingExporterConfig::None => return Ok(None),
@@ -181,19 +122,6 @@ fn tracer(config: &TracingExporterConfig) -> anyhow::Result<Option<Tracer>> {
             // The OTLP exporter already creates a tracer and installs it
             return Ok(Some(otlp_tracer(endpoint.as_ref())?));
         }
-        TracingExporterConfig::Jaeger(JaegerExporterProtocolConfig::UdpThriftCompact {
-            agent_host,
-            agent_port,
-        }) => jaeger_agent_tracer_provider(agent_host, *agent_port)?,
-        TracingExporterConfig::Jaeger(JaegerExporterProtocolConfig::HttpThriftBinary {
-            endpoint,
-            username,
-            password,
-        }) => jaeger_collector_tracer_provider(endpoint, username.as_deref(), password.as_deref())?,
-        TracingExporterConfig::Zipkin { collector_endpoint } => {
-            // The Zipkin exporter already creates a tracer and installs it
-            return Ok(Some(zipkin_tracer(collector_endpoint)?));
-        }
     };
 
     let tracer = tracer_provider.versioned_tracer(
@@ -210,7 +138,9 @@ fn tracer(config: &TracingExporterConfig) -> anyhow::Result<Option<Tracer>> {
 fn otlp_metric_reader(endpoint: Option<&url::Url>) -> anyhow::Result<PeriodicReader> {
     use opentelemetry_otlp::WithExportConfig;
 
-    let mut exporter = opentelemetry_otlp::new_exporter().tonic();
+    let mut exporter = opentelemetry_otlp::new_exporter()
+        .http()
+        .with_http_client(http_client());
     if let Some(endpoint) = endpoint {
         exporter = exporter.with_endpoint(endpoint.to_string());
     }
@@ -279,7 +209,7 @@ fn prometheus_metric_reader() -> anyhow::Result<PrometheusExporter> {
 }
 
 fn init_meter(config: &MetricsExporterConfig) -> anyhow::Result<()> {
-    let meter_provider_builder = MeterProvider::builder();
+    let meter_provider_builder = SdkMeterProvider::builder();
     let meter_provider_builder = match config {
         MetricsExporterConfig::None => meter_provider_builder.with_reader(ManualReader::default()),
         MetricsExporterConfig::Stdout => meter_provider_builder.with_reader(stdout_metric_reader()),
@@ -306,9 +236,9 @@ fn trace_config() -> opentelemetry_sdk::trace::Config {
 }
 
 fn resource() -> Resource {
-    let resource = Resource::new(vec![
-        semcov::resource::SERVICE_NAME.string(env!("CARGO_PKG_NAME")),
-        semcov::resource::SERVICE_VERSION.string(env!("CARGO_PKG_VERSION")),
+    let resource = Resource::new([
+        KeyValue::new(semcov::resource::SERVICE_NAME, env!("CARGO_PKG_NAME")),
+        KeyValue::new(semcov::resource::SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
     ]);
 
     let detected = Resource::from_detectors(

crates/config/Cargo.toml

@@ -14,7 +14,7 @@ workspace = true
 [dependencies]
 tokio = { version = "1.35.1", features = ["fs", "rt"] }
 tracing.workspace = true
-async-trait = "0.1.77"
+async-trait.workspace = true
 
 thiserror.workspace = true
 anyhow.workspace = true

crates/config/src/sections/mod.rs

@@ -46,8 +46,8 @@ pub use self::{
     policy::PolicyConfig,
     secrets::SecretsConfig,
     telemetry::{
-        JaegerExporterProtocolConfig, MetricsConfig, MetricsExporterConfig, Propagator,
-        TelemetryConfig, TracingConfig, TracingExporterConfig,
+        MetricsConfig, MetricsExporterConfig, Propagator, TelemetryConfig, TracingConfig,
+        TracingExporterConfig,
     },
     templates::TemplatesConfig,
     upstream_oauth2::{