Update dependencies and code to latest

Author: davidsteiner

Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "ddtrace"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["David Steiner <david_j_steiner@yahoo.co.nz", "Fergus Strangways-Dixon <fergusdixon101@gmail.com>"]
 edition = "2021"
 license = "MIT"
-description = "utilities for integrating Datadog with tracing"
+description = "Utilities for integrating Datadog with tracing"
 readme = "README.md"
 homepage = "https://github.com/Validus-Risk-Management/ddtrace"
 repository = "https://github.com/Validus-Risk-Management/ddtrace"
@@ -16,16 +16,18 @@ exclude = [".pre-commit-config.yaml"]
 axum = ["dep:axum", "dep:tokio", "dep:axum-tracing-opentelemetry"]
 
 [dependencies]
-axum = { version = "^0.6.10", optional = true }
-axum-tracing-opentelemetry = { version = "^0.11.0", optional = true }
-chrono = "^0.4.24"
-opentelemetry = { version = "^0.19.0", features = ["rt-tokio"] }
-opentelemetry-datadog = "^0.7.0"
-opentelemetry-otlp = { version = "^0.12.0" }
-serde = { version = "^1.0.156", features = ["derive"] }
-serde_json = "^1.0.95"
-tokio = { version = "^1.26.0", features = ["signal"], optional = true }
-tracing = "^0.1.37"
-tracing-opentelemetry = "^0.19.0"
-tracing-serde = "^0.1.3"
-tracing-subscriber = { version = "^0.3.16", features = ["env-filter", "json"] }
+axum = { version = "^0.8", optional = true }
+axum-tracing-opentelemetry = { version = "0.29", optional = true }
+chrono = "0.4"
+opentelemetry = "0.30"
+opentelemetry_sdk = "0.30"
+opentelemetry-datadog = "0.18"
+opentelemetry-otlp = { version = "0.30", features = ["grpc-tonic", "http-proto"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+thiserror = "2.0.12"
+tokio = { version = "1", features = ["signal"], optional = true }
+tracing = "0.1"
+tracing-opentelemetry = "0.31"
+tracing-serde = "0.2"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }

examples/axum/Cargo.toml

@@ -4,8 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-axum = "^0.6.12"
+axum = "0.8.4"
 ddtrace = { path = "../..", features = ["axum"] }
-tokio = { version = "^1.26.0", features = ["macros", "rt-multi-thread"] }
-tracing = "^0.1.37"
-tracing-subscriber = { version = "^0.3.16", features = ["env-filter", "json"] }
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }

examples/axum/src/main.rs

@@ -2,17 +2,18 @@ use std::net::SocketAddr;
 use std::time::Duration;
 
 use axum::{routing::get, Router};
-use ddtrace::axum::opentelemetry_tracing_layer;
+use ddtrace::axum::OtelAxumLayer;
+use ddtrace::error::Error;
 use ddtrace::formatter::DatadogFormatter;
 use ddtrace::set_global_propagator;
-use ddtrace::tracer::{build_layer, TraceResult};
+use ddtrace::tracer::build_layer;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 
 #[tokio::main]
-async fn main() -> TraceResult<()> {
+async fn main() -> Result<(), Error> {
     let service_name = std::env::var("DD_SERVICE").unwrap_or("my-service".to_string());
-    let tracing_layer = build_layer(&service_name)?;
+    let (tracing_layer, _guard) = build_layer(service_name)?;
     tracing_subscriber::registry()
         .with(tracing_subscriber::EnvFilter::new(
             std::env::var("RUST_LOG").unwrap_or_else(|_| "info".into()),
@@ -28,16 +29,13 @@ async fn main() -> TraceResult<()> {
 
     let app = Router::new()
         .route("/", get(root))
-        .layer(opentelemetry_tracing_layer())
+        .layer(OtelAxumLayer::default())
         .route("/health", get(health));
 
     let addr = SocketAddr::from(([0, 0, 0, 0], 3025));
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
     tracing::info!("listening on {}", addr);
-    axum::Server::bind(&addr)
-        .serve(app.into_make_service())
-        .with_graceful_shutdown(ddtrace::axum::shutdown_signal())
-        .await
-        .unwrap();
 
     Ok(())
 }

src/axum.rs

@@ -5,14 +5,4 @@
 //!
 //! [`axum-tracing-opentelemetry`]: https://github.com/davidB/axum-tracing-opentelemetry
 
-pub use axum_tracing_opentelemetry::opentelemetry_tracing_layer;
-pub use axum_tracing_opentelemetry::opentelemetry_tracing_layer_grpc;
-
-pub async fn shutdown_signal() {
-    tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
-        .expect("failed to install signal handler")
-        .recv()
-        .await;
-
-    opentelemetry::global::shutdown_tracer_provider();
-}
+pub use axum_tracing_opentelemetry::middleware::{OtelAxumLayer, OtelInResponseLayer};

src/error.rs

@@ -0,0 +1,5 @@
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    ExporterBuildError(#[from] opentelemetry_otlp::ExporterBuildError),
+}

src/formatter.rs

@@ -29,7 +29,7 @@ struct TraceInfo {
 
 impl From<TraceId> for DatadogId {
     fn from(value: TraceId) -> Self {
-        let bytes = &value.to_bytes()[std::mem::size_of::<u64>()..std::mem::size_of::<u128>()];
+        let bytes = &value.to_bytes()[size_of::<u64>()..size_of::<u128>()];
         Self(u64::from_be_bytes(bytes.try_into().unwrap()))
     }
 }
@@ -106,12 +106,9 @@ impl<'a> io::Write for WriteAdaptor<'a> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         let s =
             std::str::from_utf8(buf).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+        self.fmt_write.write_str(s).map_err(io::Error::other)?;
 
-        self.fmt_write
-            .write_str(s)
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-
-        Ok(s.as_bytes().len())
+        Ok(s.len())
     }
 
     fn flush(&mut self) -> io::Result<()> {

src/lib.rs

@@ -11,6 +11,7 @@
 
 #[cfg(feature = "axum")]
 pub mod axum;
+pub mod error;
 pub mod formatter;
 mod propagator;
 pub mod tracer;

src/tracer.rs

@@ -4,41 +4,53 @@
 //! to send traces to the Datadog agent in batches over gRPC.
 //!
 //! It also contains a convenience function to build a layer with the tracer.
-use opentelemetry::sdk::trace::{RandomIdGenerator, Sampler, Tracer};
-use opentelemetry::sdk::{trace, Resource};
-pub use opentelemetry::trace::{TraceError, TraceResult};
-use opentelemetry::KeyValue;
+use crate::error::Error;
+use opentelemetry::trace::TracerProvider;
 use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_sdk::trace::{RandomIdGenerator, Sampler, SdkTracerProvider, Tracer};
+use opentelemetry_sdk::Resource;
 use std::time::Duration;
 use tracing::Subscriber;
 use tracing_opentelemetry::{OpenTelemetryLayer, PreSampledTracer};
 use tracing_subscriber::registry::LookupSpan;
 
-pub fn build_tracer(service_name: &str) -> TraceResult<Tracer> {
-    let exporter = opentelemetry_otlp::new_exporter()
-        .tonic()
-        .with_timeout(Duration::from_secs(3));
+pub struct ProviderGuard {
+    tracer_provider: SdkTracerProvider,
+}
+
+impl Drop for ProviderGuard {
+    fn drop(&mut self) {
+        let _ = self.tracer_provider.force_flush();
+        let _ = self.tracer_provider.shutdown();
+    }
+}
+
+pub fn build_tracer_provider(service_name: String) -> Result<SdkTracerProvider, Error> {
+    let exporter = opentelemetry_otlp::SpanExporter::builder()
+        .with_tonic()
+        .with_timeout(Duration::from_secs(3))
+        .build()?;
+    let resource = Resource::builder().with_service_name(service_name).build();
+
+    let provider = SdkTracerProvider::builder()
+        .with_sampler(Sampler::AlwaysOn)
+        .with_resource(resource)
+        .with_id_generator(RandomIdGenerator::default())
+        .with_batch_exporter(exporter)
+        .build();
 
-    opentelemetry_otlp::new_pipeline()
-        .tracing()
-        .with_trace_config(
-            trace::config()
-                .with_sampler(Sampler::AlwaysOn)
-                .with_resource(Resource::new(vec![KeyValue::new(
-                    "service.name",
-                    service_name.to_string(),
-                )]))
-                .with_id_generator(RandomIdGenerator::default()),
-        )
-        .with_exporter(exporter)
-        .install_batch(opentelemetry::runtime::Tokio)
+    Ok(provider)
 }
 
-pub fn build_layer<S>(service_name: &str) -> TraceResult<OpenTelemetryLayer<S, Tracer>>
+pub fn build_layer<S>(
+    service_name: String,
+) -> Result<(OpenTelemetryLayer<S, Tracer>, ProviderGuard), Error>
 where
     Tracer: opentelemetry::trace::Tracer + PreSampledTracer + 'static,
     S: Subscriber + for<'span> LookupSpan<'span>,
 {
-    let tracer = build_tracer(service_name)?;
-    Ok(tracing_opentelemetry::layer().with_tracer(tracer))
+    let tracer_provider = build_tracer_provider(service_name)?;
+    let layer = tracing_opentelemetry::layer().with_tracer(tracer_provider.tracer(""));
+    let guard = ProviderGuard { tracer_provider };
+    Ok((layer, guard))
 }