move TraceError, TraceResult and ExportError to opentelemetry-sdk (#2680)

Co-authored-by: Cijo Thomas <[email protected]>

Author: gruebel

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,
@@ -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/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");

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

@@ -5,7 +5,7 @@
 use std::fmt::Debug;
 
 use opentelemetry_sdk::error::OTelSdkResult;
-use opentelemetry_sdk::trace::SpanData;
+use opentelemetry_sdk::trace::{SpanData, TraceError};
 
 #[cfg(feature = "grpc-tonic")]
 use crate::{
@@ -62,7 +62,7 @@ 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(span_exporter)
@@ -71,7 +71,7 @@ impl SpanExporterBuilder<TonicExporterBuilderSet> {
 
 #[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(span_exporter)
     }

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

@@ -5,6 +5,9 @@
 - 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
 

opentelemetry-sdk/src/testing/trace/span_exporters.rs

@@ -2,6 +2,7 @@ use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::{
     trace::{SpanData, SpanExporter},
     trace::{SpanEvents, SpanLinks},
+    ExportError,
 };
 pub use opentelemetry::testing::trace::TestSpan;
 use opentelemetry::{
@@ -74,7 +75,7 @@ pub struct TestExportError(String);
 
 impl std::error::Error for TestExportError {}
 
-impl opentelemetry::trace::ExportError for TestExportError {
+impl ExportError for TestExportError {
     fn exporter_name(&self) -> &'static str {
         "test"
     }

opentelemetry-sdk/src/trace/error.rs

@@ -0,0 +1,60 @@
+use crate::ExportError;
+use std::sync::PoisonError;
+use std::time;
+use thiserror::Error;
+
+/// A specialized `Result` type for trace operations.
+pub type TraceResult<T> = Result<T, TraceError>;
+
+/// Errors returned by the trace API.
+#[derive(Error, Debug)]
+#[non_exhaustive]
+pub enum TraceError {
+    /// Export failed with the error returned by the exporter
+    #[error("Exporter {0} encountered the following error(s): {name}", name = .0.exporter_name())]
+    ExportFailed(Box<dyn ExportError>),
+
+    /// Export failed to finish after certain period and processor stopped the export.
+    #[error("Exporting timed out after {} seconds", .0.as_secs())]
+    ExportTimedOut(time::Duration),
+
+    /// already shutdown error
+    #[error("TracerProvider already shutdown")]
+    TracerProviderAlreadyShutdown,
+
+    /// Other errors propagated from trace SDK that weren't covered above
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
+}
+
+impl<T> From<T> for TraceError
+where
+    T: ExportError,
+{
+    fn from(err: T) -> Self {
+        TraceError::ExportFailed(Box::new(err))
+    }
+}
+
+impl From<String> for TraceError {
+    fn from(err_msg: String) -> Self {
+        TraceError::Other(err_msg.into())
+    }
+}
+
+impl From<&'static str> for TraceError {
+    fn from(err_msg: &'static str) -> Self {
+        TraceError::Other(Box::new(Custom(err_msg.into())))
+    }
+}
+
+impl<T> From<PoisonError<T>> for TraceError {
+    fn from(err: PoisonError<T>) -> Self {
+        TraceError::Other(err.to_string().into())
+    }
+}
+
+/// Wrap type for string
+#[derive(Error, Debug)]
+#[error("{0}")]
+struct Custom(String);

opentelemetry-sdk/src/trace/in_memory_exporter.rs

@@ -1,7 +1,7 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::resource::Resource;
+use crate::trace::error::{TraceError, TraceResult};
 use crate::trace::{SpanData, SpanExporter};
-use opentelemetry::trace::{TraceError, TraceResult};
 use std::sync::{Arc, Mutex};
 
 /// An in-memory span exporter that stores span data in memory.