Merge branch 'main' into modify-batchProcessor-test-use-flush-instead-of-sleeptime

Author: mohammadVatandoost

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"

examples/tracing-jaeger/src/main.rs

@@ -1,9 +1,9 @@
 use opentelemetry::{
     global,
-    trace::{TraceContextExt, TraceError, Tracer},
+    trace::{TraceContextExt, Tracer},
     KeyValue,
 };
-use opentelemetry_sdk::trace::SdkTracerProvider;
+use opentelemetry_sdk::trace::{SdkTracerProvider, TraceError};
 use opentelemetry_sdk::Resource;
 
 use std::error::Error;

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

@@ -210,7 +210,7 @@ impl HttpExporterBuilder {
     #[cfg(feature = "trace")]
     pub fn build_span_exporter(
         mut self,
-    ) -> Result<crate::SpanExporter, opentelemetry::trace::TraceError> {
+    ) -> Result<crate::SpanExporter, opentelemetry_sdk::trace::TraceError> {
         use crate::{
             OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_HEADERS,
             OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
@@ -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
@@ -301,7 +301,7 @@ impl OtlpHttpClient {
     fn build_trace_export_body(
         &self,
         spans: Vec<SpanData>,
-    ) -> opentelemetry::trace::TraceResult<(Vec<u8>, &'static str)> {
+    ) -> opentelemetry_sdk::trace::TraceResult<(Vec<u8>, &'static str)> {
         use opentelemetry_proto::tonic::collector::trace::v1::ExportTraceServiceRequest;
         let resource_spans = group_spans_by_resource_and_scope(spans, &self.resource);
 
@@ -310,7 +310,7 @@ impl OtlpHttpClient {
             #[cfg(feature = "http-json")]
             Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
                 Ok(json) => Ok((json.into(), "application/json")),
-                Err(e) => Err(opentelemetry::trace::TraceError::from(e.to_string())),
+                Err(e) => Err(opentelemetry_sdk::trace::TraceError::from(e.to_string())),
             },
             _ => Ok((req.encode_to_vec(), "application/x-protobuf")),
         }

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

@@ -303,7 +303,7 @@ impl TonicExporterBuilder {
     #[cfg(feature = "trace")]
     pub(crate) fn build_span_exporter(
         self,
-    ) -> Result<crate::SpanExporter, opentelemetry::trace::TraceError> {
+    ) -> Result<crate::SpanExporter, opentelemetry_sdk::trace::TraceError> {
         use crate::exporter::tonic::trace::TonicTracesClient;
 
         otel_debug!(name: "TracesTonicChannelBuilding");
@@ -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/lib.rs

@@ -384,12 +384,6 @@ impl ExportError for Error {
     }
 }
 
-impl opentelemetry::trace::ExportError for Error {
-    fn exporter_name(&self) -> &'static str {
-        "otlp"
-    }
-}
-
 /// The communication protocol to use when exporting data.
 #[cfg_attr(feature = "serialize", derive(Deserialize, Serialize))]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]

opentelemetry-otlp/src/span.rs

@@ -4,9 +4,8 @@
 
 use std::fmt::Debug;
 
-use futures_core::future::BoxFuture;
 use opentelemetry_sdk::error::OTelSdkResult;
-use opentelemetry_sdk::trace::SpanData;
+use opentelemetry_sdk::trace::{SpanData, TraceError};
 
 #[cfg(feature = "grpc-tonic")]
 use crate::{
@@ -63,18 +62,18 @@ impl SpanExporterBuilder<NoExporterBuilderSet> {
 
 #[cfg(feature = "grpc-tonic")]
 impl SpanExporterBuilder<TonicExporterBuilderSet> {
-    pub fn build(self) -> Result<SpanExporter, opentelemetry::trace::TraceError> {
+    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, opentelemetry::trace::TraceError> {
+    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-otlp/tests/integration_test/tests/traces.rs

@@ -3,15 +3,14 @@
 use std::{fs::File, os::unix::fs::MetadataExt};
 
 use integration_test_runner::trace_asserter::{read_spans_from_json, TraceAsserter};
-use opentelemetry::trace::TraceError;
 use opentelemetry_otlp::SpanExporter;
 
 use anyhow::Result;
 use ctor::dtor;
 use integration_test_runner::test_utils;
 use opentelemetry_sdk::{trace as sdktrace, Resource};
 
-fn init_tracer_provider() -> Result<sdktrace::SdkTracerProvider, TraceError> {
+fn init_tracer_provider() -> Result<sdktrace::SdkTracerProvider, sdktrace::TraceError> {
     let exporter_builder = SpanExporter::builder();
     #[cfg(feature = "tonic-client")]
     let exporter_builder = exporter_builder.with_tonic();

opentelemetry-sdk/CHANGELOG.md

@@ -2,7 +2,12 @@
 
 ## 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`
 
 ## 0.28.0