Update opentelemetry to 0.24.0

Author: sandhose

Cargo.lock

@@ -79,7 +79,7 @@ features = ["cookie-private", "cookie-key-expansion", "typed-header"]
 
 # Bytes
 [workspace.dependencies.bytes]
-version = "1.6.0"
+version = "1.6.1"
 
 # UTF-8 paths
 [workspace.dependencies.camino]
@@ -241,14 +241,15 @@ version = "0.3.18"
 
 # OpenTelemetry
 [workspace.dependencies.opentelemetry]
-version = "0.23.0"
+version = "0.24.0"
 features = ["trace", "metrics"]
 [workspace.dependencies.opentelemetry-http]
-version = "0.12.0"
+version = "0.13.0"
+features = ["hyper"]
 [workspace.dependencies.opentelemetry-semantic-conventions]
-version = "0.15.0"
+version = "0.16.0"
 [workspace.dependencies.tracing-opentelemetry]
-version = "0.24.0"
+version = "0.25.0"
 default-features = false
 
 # URL manipulation

Cargo.toml

@@ -47,13 +47,13 @@ tracing-subscriber = { workspace = true, features = ["env-filter"] }
 tracing-opentelemetry.workspace = true
 opentelemetry.workspace = true
 opentelemetry-http.workspace = true
-opentelemetry-jaeger-propagator = "0.2.0"
-opentelemetry-otlp = { version = "0.16.0", default-features = false, features = ["trace", "metrics", "http-proto"] }
-opentelemetry-prometheus = "0.16.0"
-opentelemetry-resource-detectors = "0.2.0"
+opentelemetry-jaeger-propagator = "0.3.0"
+opentelemetry-otlp = { version = "0.17.0", default-features = false, features = ["trace", "metrics", "http-proto"] }
+opentelemetry-prometheus = "0.17.0"
+opentelemetry-resource-detectors = "0.3.0"
 opentelemetry-semantic-conventions.workspace = true
-opentelemetry-stdout = { version = "0.4.0", features = ["trace", "metrics"] }
-opentelemetry_sdk = { version = "0.23.0", features = ["trace", "metrics", "rt-tokio"] }
+opentelemetry-stdout = { version = "0.5.0", features = ["trace", "metrics"] }
+opentelemetry_sdk = { version = "0.24.1", features = ["trace", "metrics", "rt-tokio"] }
 prometheus = "0.13.4"
 sentry.workspace = true
 sentry-tracing.workspace = true

crates/cli/Cargo.toml

@@ -34,7 +34,7 @@ use mas_storage::{BoxClock, BoxRepository, BoxRng, Repository, SystemClock};
 use mas_storage_pg::PgRepository;
 use mas_templates::Templates;
 use opentelemetry::{
-    metrics::{Histogram, MetricsError, Unit},
+    metrics::{Histogram, MetricsError},
     KeyValue,
 };
 use rand::SeedableRng;
@@ -78,13 +78,13 @@ impl AppState {
         let usage = meter
             .i64_observable_up_down_counter("db.connections.usage")
             .with_description("The number of connections that are currently in `state` described by the state attribute.")
-            .with_unit(Unit::new("{connection}"))
+            .with_unit("{connection}")
             .init();
 
         let max = meter
             .i64_observable_up_down_counter("db.connections.max")
             .with_description("The maximum number of open connections allowed.")
-            .with_unit(Unit::new("{connection}"))
+            .with_unit("{connection}")
             .init();
 
         // Observe the number of active and idle connections in the pool
@@ -101,7 +101,7 @@ impl AppState {
         let histogram = meter
             .u64_histogram("db.client.connections.create_time")
             .with_description("The time it took to create a new connection.")
-            .with_unit(Unit::new("ms"))
+            .with_unit("ms")
             .init();
         self.conn_acquisition_histogram = Some(histogram);
 

crates/cli/src/app_state.rs

@@ -22,7 +22,6 @@ use mas_config::{
     MetricsConfig, MetricsExporterKind, Propagator, TelemetryConfig, TracingConfig,
     TracingExporterKind,
 };
-use mas_http::OtelClient;
 use opentelemetry::{
     global,
     propagation::{TextMapCompositePropagator, TextMapPropagator},
@@ -99,7 +98,7 @@ fn propagator(propagators: &[Propagator]) -> impl TextMapPropagator {
 
 fn http_client() -> impl opentelemetry_http::HttpClient + 'static {
     let client = mas_http::make_untraced_client();
-    OtelClient::new(client)
+    opentelemetry_http::hyper::HyperClient::new_with_timeout(client, Duration::from_secs(30))
 }
 
 fn stdout_tracer_provider() -> TracerProvider {
@@ -109,7 +108,7 @@ fn stdout_tracer_provider() -> TracerProvider {
         .build()
 }
 
-fn otlp_tracer(endpoint: Option<&Url>) -> anyhow::Result<Tracer> {
+fn otlp_tracer_provider(endpoint: Option<&Url>) -> anyhow::Result<TracerProvider> {
     use opentelemetry_otlp::WithExportConfig;
 
     let mut exporter = opentelemetry_otlp::new_exporter()
@@ -133,10 +132,7 @@ fn tracer(config: &TracingConfig) -> anyhow::Result<Option<Tracer>> {
     let tracer_provider = match config.exporter {
         TracingExporterKind::None => return Ok(None),
         TracingExporterKind::Stdout => stdout_tracer_provider(),
-        TracingExporterKind::Otlp => {
-            // The OTLP exporter already creates a tracer and installs it
-            return Ok(Some(otlp_tracer(config.endpoint.as_ref())?));
-        }
+        TracingExporterKind::Otlp => otlp_tracer_provider(config.endpoint.as_ref())?,
     };
 
     let tracer = tracer_provider
@@ -248,7 +244,7 @@ fn init_meter(config: &MetricsConfig) -> anyhow::Result<()> {
 }
 
 fn trace_config() -> opentelemetry_sdk::trace::Config {
-    opentelemetry_sdk::trace::config()
+    opentelemetry_sdk::trace::Config::default()
         .with_resource(resource())
         .with_sampler(Sampler::AlwaysOn)
 }

crates/cli/src/telemetry.rs

@@ -65,7 +65,7 @@ impl Worker {
         let message_counter = meter
             .u64_counter("mas.activity_tracker.messages")
             .with_description("The number of messages received by the activity tracker")
-            .with_unit(opentelemetry::metrics::Unit::new("{messages}"))
+            .with_unit("{messages}")
             .init();
 
         // Record stuff on the counter so that the metrics are initialized
@@ -85,7 +85,7 @@ impl Worker {
         let flush_time_histogram = meter
             .u64_histogram("mas.activity_tracker.flush_time")
             .with_description("The time it took to flush the activity tracker")
-            .with_unit(opentelemetry::metrics::Unit::new("ms"))
+            .with_unit("ms")
             .init();
 
         Self {

crates/handlers/src/activity_tracker/worker.rs

@@ -23,7 +23,6 @@ hyper.workspace = true
 hyper-util.workspace = true
 hyper-rustls = { workspace = true, optional = true }
 opentelemetry.workspace = true
-opentelemetry-http = { workspace = true, optional = true }
 opentelemetry-semantic-conventions.workspace = true
 rustls = { workspace = true, optional = true }
 rustls-platform-verifier = { workspace = true, optional = true }
@@ -37,9 +36,6 @@ tower-http.workspace = true
 tracing.workspace = true
 tracing-opentelemetry.workspace = true
 
-# opentelemetry-http still requires http 0.2, and we need to convert types
-http02 = { package = "http", version = "0.2.12", optional = true }
-
 mas-tower = { workspace = true, optional = true }
 
 [dev-dependencies]
@@ -52,8 +48,6 @@ client = [
     "dep:rustls",
     "dep:hyper-rustls",
     "dep:rustls-platform-verifier",
-    "dep:http02",
-    "dep:opentelemetry-http",
     "tower/limit",
     "tower-http/timeout",
     "tower-http/follow-redirect",

crates/http/Cargo.toml

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use bytes::Bytes;
-use http_body_util::{BodyExt, Full};
 use hyper_rustls::{HttpsConnector, HttpsConnectorBuilder};
 pub use hyper_util::client::legacy::Client;
 use hyper_util::{
@@ -27,7 +25,6 @@ use mas_tower::{
     DurationRecorderLayer, DurationRecorderService, FnWrapper, InFlightCounterLayer,
     InFlightCounterService, TraceLayer, TraceService,
 };
-use opentelemetry_http::HttpClient;
 use opentelemetry_semantic_conventions::trace::SERVER_ADDRESS;
 use tower::Layer;
 use tracing::Span;
@@ -97,76 +94,3 @@ fn make_connector<R>(
         .enable_http2()
         .wrap_connector(http)
 }
-
-/// A client which can be used by opentelemetry-http to send request through
-/// hyper 1.x
-///
-/// This is needed until OTEL upgrades to hyper 1.x
-/// <https://github.com/open-telemetry/opentelemetry-rust/pull/1674>
-#[derive(Debug)]
-pub struct OtelClient {
-    client: UntracedClient<Full<Bytes>>,
-}
-
-impl OtelClient {
-    /// Create a new [`OtelClient`] from a [`UntracedClient`]
-    #[must_use]
-    pub fn new(client: UntracedClient<Full<Bytes>>) -> Self {
-        Self { client }
-    }
-}
-
-#[async_trait::async_trait]
-impl HttpClient for OtelClient {
-    async fn send(
-        &self,
-        request: opentelemetry_http::Request<Vec<u8>>,
-    ) -> Result<opentelemetry_http::Response<Bytes>, opentelemetry_http::HttpError> {
-        // This is the annoying part: converting the OTEL http0.2 request to a http1
-        // request
-        let (parts, body) = request.into_parts();
-        let body = Full::new(Bytes::from(body));
-        let mut request = http::Request::new(body);
-
-        *request.uri_mut() = parts.uri.to_string().parse().unwrap();
-        *request.method_mut() = match parts.method {
-            http02::Method::GET => http::Method::GET,
-            http02::Method::POST => http::Method::POST,
-            http02::Method::PUT => http::Method::PUT,
-            http02::Method::DELETE => http::Method::DELETE,
-            http02::Method::HEAD => http::Method::HEAD,
-            http02::Method::OPTIONS => http::Method::OPTIONS,
-            http02::Method::CONNECT => http::Method::CONNECT,
-            http02::Method::PATCH => http::Method::PATCH,
-            http02::Method::TRACE => http::Method::TRACE,
-            _ => return Err(opentelemetry_http::HttpError::from("Unsupported method")),
-        };
-        request
-            .headers_mut()
-            .extend(parts.headers.into_iter().map(|(k, v)| {
-                (
-                    k.map(|k| http::HeaderName::from_bytes(k.as_ref()).unwrap()),
-                    http::HeaderValue::from_bytes(v.as_ref()).unwrap(),
-                )
-            }));
-
-        // Send the request
-        let response = self.client.request(request).await?;
-
-        // Convert back the response
-        let (parts, body) = response.into_parts();
-        let body = body.collect().await?.to_bytes();
-        let mut response = opentelemetry_http::Response::new(body);
-        *response.status_mut() = parts.status.as_u16().try_into().unwrap();
-        response
-            .headers_mut()
-            .extend(parts.headers.into_iter().map(|(k, v)| {
-                (
-                    k.map(|k| http02::HeaderName::from_bytes(k.as_ref()).unwrap()),
-                    http02::HeaderValue::from_bytes(v.as_ref()).unwrap(),
-                )
-            }));
-
-        Ok(response)
-    }
-}

crates/http/src/client.rs

@@ -21,10 +21,13 @@ use mas_tower::{
     TraceLayer, TraceService,
 };
 use opentelemetry::KeyValue;
-use opentelemetry_semantic_conventions::trace::{
-    CLIENT_ADDRESS, CLIENT_PORT, HTTP_REQUEST_BODY_SIZE, HTTP_REQUEST_METHOD,
-    HTTP_RESPONSE_BODY_SIZE, HTTP_RESPONSE_STATUS_CODE, NETWORK_PROTOCOL_NAME, NETWORK_TRANSPORT,
-    NETWORK_TYPE, SERVER_ADDRESS, SERVER_PORT, URL_FULL, USER_AGENT_ORIGINAL,
+use opentelemetry_semantic_conventions::{
+    attribute::{HTTP_REQUEST_BODY_SIZE, HTTP_RESPONSE_BODY_SIZE},
+    trace::{
+        CLIENT_ADDRESS, CLIENT_PORT, HTTP_REQUEST_METHOD, HTTP_RESPONSE_STATUS_CODE,
+        NETWORK_PROTOCOL_NAME, NETWORK_TRANSPORT, NETWORK_TYPE, SERVER_ADDRESS, SERVER_PORT,
+        URL_FULL, USER_AGENT_ORIGINAL,
+    },
 };
 use tower::{
     limit::{ConcurrencyLimit, GlobalConcurrencyLimitLayer},

crates/http/src/layers/client.rs

@@ -26,8 +26,8 @@ mod service;
 #[cfg(feature = "client")]
 pub use self::{
     client::{
-        make_traced_connector, make_untraced_client, Client, OtelClient, TracedClient,
-        TracedConnector, UntracedClient, UntracedConnector,
+        make_traced_connector, make_untraced_client, Client, TracedClient, TracedConnector,
+        UntracedClient, UntracedConnector,
     },
     layers::client::{ClientLayer, ClientService},
 };