Merge remote-tracking branch 'origin/main' into move-trace-error-v2

# Conflicts:
#	opentelemetry-sdk/CHANGELOG.md
#	opentelemetry-sdk/src/trace/in_memory_exporter.rs
#	opentelemetry/CHANGELOG.md

Author: gruebel

Cargo.toml

@@ -36,7 +36,7 @@ pin-project-lite = "0.2"
 prost = "0.13"
 prost-build = "0.13"
 prost-types = "0.13"
-rand = { version = "0.8", default-features = false }
+rand = { version = "0.9", default-features = false }
 reqwest = { version = "0.12", default-features = false }
 serde = { version = "1.0", default-features = false }
 serde_json = "1.0"

opentelemetry-otlp/src/exporter/http/mod.rs

@@ -223,7 +223,7 @@ impl HttpExporterBuilder {
             OTEL_EXPORTER_OTLP_TRACES_HEADERS,
         )?;
 
-        Ok(crate::SpanExporter::new(client))
+        Ok(crate::SpanExporter::from_http(client))
     }
 
     /// Create a log exporter with the current configuration

opentelemetry-otlp/src/exporter/http/trace.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use super::OtlpHttpClient;
-use futures_core::future::BoxFuture;
 use http::{header::CONTENT_TYPE, Method};
 use opentelemetry::otel_debug;
 use opentelemetry_sdk::{
@@ -10,7 +9,7 @@ use opentelemetry_sdk::{
 };
 
 impl SpanExporter for OtlpHttpClient {
-    fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, OTelSdkResult> {
+    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
         let client = match self
             .client
             .lock()
@@ -20,16 +19,12 @@ impl SpanExporter for OtlpHttpClient {
                 _ => Err(OTelSdkError::AlreadyShutdown),
             }) {
             Ok(client) => client,
-            Err(err) => return Box::pin(std::future::ready(Err(err))),
+            Err(err) => return Err(err),
         };
 
         let (body, content_type) = match self.build_trace_export_body(batch) {
             Ok(body) => body,
-            Err(e) => {
-                return Box::pin(std::future::ready(Err(OTelSdkError::InternalFailure(
-                    e.to_string(),
-                ))))
-            }
+            Err(e) => return Err(OTelSdkError::InternalFailure(e.to_string())),
         };
 
         let mut request = match http::Request::builder()
@@ -39,37 +34,31 @@ impl SpanExporter for OtlpHttpClient {
             .body(body.into())
         {
             Ok(req) => req,
-            Err(e) => {
-                return Box::pin(std::future::ready(Err(OTelSdkError::InternalFailure(
-                    e.to_string(),
-                ))))
-            }
+            Err(e) => return Err(OTelSdkError::InternalFailure(e.to_string())),
         };
 
         for (k, v) in &self.headers {
             request.headers_mut().insert(k.clone(), v.clone());
         }
 
-        Box::pin(async move {
-            let request_uri = request.uri().to_string();
-            otel_debug!(name: "HttpTracesClient.CallingExport");
-            let response = client
-                .send_bytes(request)
-                .await
-                .map_err(|e| OTelSdkError::InternalFailure(format!("{e:?}")))?;
+        let request_uri = request.uri().to_string();
+        otel_debug!(name: "HttpTracesClient.CallingExport");
+        let response = client
+            .send_bytes(request)
+            .await
+            .map_err(|e| OTelSdkError::InternalFailure(format!("{e:?}")))?;
 
-            if !response.status().is_success() {
-                let error = format!(
-                    "OpenTelemetry trace export failed. Url: {}, Status Code: {}, Response: {:?}",
-                    response.status().as_u16(),
-                    request_uri,
-                    response.body()
-                );
-                return Err(OTelSdkError::InternalFailure(error));
-            }
+        if !response.status().is_success() {
+            let error = format!(
+                "OpenTelemetry trace export failed. Url: {}, Status Code: {}, Response: {:?}",
+                response.status().as_u16(),
+                request_uri,
+                response.body()
+            );
+            return Err(OTelSdkError::InternalFailure(error));
+        }
 
-            Ok(())
-        })
+        Ok(())
     }
 
     fn shutdown(&mut self) -> OTelSdkResult {

opentelemetry-otlp/src/exporter/tonic/mod.rs

@@ -317,7 +317,7 @@ impl TonicExporterBuilder {
 
         let client = TonicTracesClient::new(channel, interceptor, compression);
 
-        Ok(crate::SpanExporter::new(client))
+        Ok(crate::SpanExporter::from_tonic(client))
     }
 }
 

opentelemetry-otlp/src/exporter/tonic/trace.rs

@@ -1,6 +1,5 @@
 use core::fmt;
 
-use futures_core::future::BoxFuture;
 use opentelemetry::otel_debug;
 use opentelemetry_proto::tonic::collector::trace::v1::{
     trace_service_client::TraceServiceClient, ExportTraceServiceRequest,
@@ -59,39 +58,33 @@ impl TonicTracesClient {
 }
 
 impl SpanExporter for TonicTracesClient {
-    fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, OTelSdkResult> {
+    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
         let (mut client, metadata, extensions) = match &mut self.inner {
             Some(inner) => {
                 let (m, e, _) = match inner.interceptor.call(Request::new(())) {
                     Ok(res) => res.into_parts(),
-                    Err(e) => {
-                        return Box::pin(std::future::ready(Err(OTelSdkError::InternalFailure(
-                            e.to_string(),
-                        ))))
-                    }
+                    Err(e) => return Err(OTelSdkError::InternalFailure(e.to_string())),
                 };
                 (inner.client.clone(), m, e)
             }
             None => {
-                return Box::pin(std::future::ready(Err(OTelSdkError::AlreadyShutdown)));
+                return Err(OTelSdkError::AlreadyShutdown);
             }
         };
 
         let resource_spans = group_spans_by_resource_and_scope(batch, &self.resource);
 
         otel_debug!(name: "TonicsTracesClient.CallingExport");
 
-        Box::pin(async move {
-            client
-                .export(Request::from_parts(
-                    metadata,
-                    extensions,
-                    ExportTraceServiceRequest { resource_spans },
-                ))
-                .await
-                .map_err(|e| OTelSdkError::InternalFailure(e.to_string()))?;
-            Ok(())
-        })
+        client
+            .export(Request::from_parts(
+                metadata,
+                extensions,
+                ExportTraceServiceRequest { resource_spans },
+            ))
+            .await
+            .map_err(|e| OTelSdkError::InternalFailure(e.to_string()))?;
+        Ok(())
     }
 
     fn shutdown(&mut self) -> OTelSdkResult {

opentelemetry-otlp/src/span.rs

@@ -4,7 +4,6 @@
 
 use std::fmt::Debug;
 
-use futures_core::future::BoxFuture;
 use opentelemetry_sdk::error::OTelSdkResult;
 use opentelemetry_sdk::trace::{SpanData, TraceError};
 
@@ -66,15 +65,15 @@ impl SpanExporterBuilder<TonicExporterBuilderSet> {
     pub fn build(self) -> Result<SpanExporter, TraceError> {
         let span_exporter = self.client.0.build_span_exporter()?;
         opentelemetry::otel_debug!(name: "SpanExporterBuilt");
-        Ok(SpanExporter::new(span_exporter))
+        Ok(span_exporter)
     }
 }
 
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
 impl SpanExporterBuilder<HttpExporterBuilderSet> {
     pub fn build(self) -> Result<SpanExporter, TraceError> {
         let span_exporter = self.client.0.build_span_exporter()?;
-        Ok(SpanExporter::new(span_exporter))
+        Ok(span_exporter)
     }
 }
 
@@ -106,28 +105,57 @@ impl HasHttpConfig for SpanExporterBuilder<HttpExporterBuilderSet> {
     }
 }
 
-/// OTLP exporter that sends tracing information
+/// OTLP exporter that sends tracing data
 #[derive(Debug)]
-pub struct SpanExporter(Box<dyn opentelemetry_sdk::trace::SpanExporter>);
+pub struct SpanExporter {
+    client: SupportedTransportClient,
+}
+
+#[derive(Debug)]
+enum SupportedTransportClient {
+    #[cfg(feature = "grpc-tonic")]
+    Tonic(crate::exporter::tonic::trace::TonicTracesClient),
+    #[cfg(any(feature = "http-proto", feature = "http-json"))]
+    Http(crate::exporter::http::OtlpHttpClient),
+}
 
 impl SpanExporter {
     /// Obtain a builder to configure a [SpanExporter].
     pub fn builder() -> SpanExporterBuilder<NoExporterBuilderSet> {
         SpanExporterBuilder::default()
     }
 
-    /// Build a new span exporter from a client
-    pub fn new(client: impl opentelemetry_sdk::trace::SpanExporter + 'static) -> Self {
-        SpanExporter(Box::new(client))
+    #[cfg(any(feature = "http-proto", feature = "http-json"))]
+    pub(crate) fn from_http(client: crate::exporter::http::OtlpHttpClient) -> Self {
+        SpanExporter {
+            client: SupportedTransportClient::Http(client),
+        }
+    }
+
+    #[cfg(feature = "grpc-tonic")]
+    pub(crate) fn from_tonic(client: crate::exporter::tonic::trace::TonicTracesClient) -> Self {
+        SpanExporter {
+            client: SupportedTransportClient::Tonic(client),
+        }
     }
 }
 
 impl opentelemetry_sdk::trace::SpanExporter for SpanExporter {
-    fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, OTelSdkResult> {
-        self.0.export(batch)
+    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
+        match &mut self.client {
+            #[cfg(feature = "grpc-tonic")]
+            SupportedTransportClient::Tonic(client) => client.export(batch).await,
+            #[cfg(any(feature = "http-proto", feature = "http-json"))]
+            SupportedTransportClient::Http(client) => client.export(batch).await,
+        }
     }
 
     fn set_resource(&mut self, resource: &opentelemetry_sdk::Resource) {
-        self.0.set_resource(resource);
+        match &mut self.client {
+            #[cfg(feature = "grpc-tonic")]
+            SupportedTransportClient::Tonic(client) => client.set_resource(resource),
+            #[cfg(any(feature = "http-proto", feature = "http-json"))]
+            SupportedTransportClient::Http(client) => client.set_resource(resource),
+        }
     }
 }

opentelemetry-sdk/CHANGELOG.md

@@ -2,7 +2,9 @@
 
 ## vNext
 
-- *Breaking* Make `force_flush()` in `PushMetricExporter` synchronous
+- Calls to `MeterProviderBuilder::with_resource`, `TracerProviderBuilder::with_resource`, 
+  `LoggerProviderBuilder::with_resource` are now additive ([#2677](https://github.com/open-telemetry/opentelemetry-rust/pull/2677)).
+- *Breaking*: Make `force_flush()` in `PushMetricExporter` synchronous
 - Moved `ExportError` trait from `opentelemetry::trace::ExportError` to `opentelemetry_sdk::export::ExportError`
 - Moved `TraceError` enum from `opentelemetry::trace::TraceError` to `opentelemetry_sdk::trace::TraceError`
 - Moved `TraceResult` type alias from `opentelemetry::trace::TraceResult` to `opentelemetry_sdk::trace::TraceResult`

opentelemetry-sdk/Cargo.toml

@@ -17,7 +17,7 @@ futures-channel = "0.3"
 futures-executor = { workspace = true }
 futures-util = { workspace = true, features = ["std", "sink", "async-await-macro"] }
 percent-encoding = { version = "2.0", optional = true }
-rand = { workspace = true, features = ["std", "std_rng","small_rng"], optional = true }
+rand = { workspace = true, features = ["std", "std_rng", "small_rng", "os_rng", "thread_rng"], optional = true }
 glob = { version = "0.3.1", optional =true}
 serde = { workspace = true, features = ["derive", "rc"], optional = true }
 serde_json = { workspace = true, optional = true }

opentelemetry-sdk/benches/context.rs

@@ -1,5 +1,4 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
-use futures_util::future::BoxFuture;
 use opentelemetry::{
     global::BoxedTracer,
     trace::{
@@ -137,8 +136,8 @@ fn parent_sampled_tracer(inner_sampler: Sampler) -> (SdkTracerProvider, BoxedTra
 struct NoopExporter;
 
 impl SpanExporter for NoopExporter {
-    fn export(&mut self, _spans: Vec<SpanData>) -> BoxFuture<'static, OTelSdkResult> {
-        Box::pin(futures_util::future::ready(Ok(())))
+    async fn export(&mut self, _spans: Vec<SpanData>) -> OTelSdkResult {
+        Ok(())
     }
 }
 

opentelemetry-sdk/benches/metric.rs

@@ -301,7 +301,7 @@ fn bench_histogram(bound_count: usize) -> (SharedReader, Histogram<u64>) {
 
 fn histograms(c: &mut Criterion) {
     let mut group = c.benchmark_group("Histogram");
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     for bound_size in [10, 49, 50, 1000].iter() {
         let (_, hist) = bench_histogram(*bound_size);
@@ -313,7 +313,7 @@ fn histograms(c: &mut Criterion) {
                     format!("V,{},{},{}", bound_size, attr_size, i),
                 ))
             }
-            let value: u64 = rng.gen_range(0..MAX_BOUND).try_into().unwrap();
+            let value: u64 = rng.random_range(0..MAX_BOUND).try_into().unwrap();
             group.bench_function(
                 format!("Record{}Attrs{}bounds", attr_size, bound_size),
                 |b| b.iter(|| hist.record(value, &attributes)),