refactor: unify sdk error types (#3458)

Co-authored-by: Cijo Thomas <cithomas@microsoft.com>
Co-authored-by: Cijo Thomas <cijo.thomas@gmail.com>

Author: rornic

opentelemetry-sdk/CHANGELOG.md

@@ -34,6 +34,7 @@
 - Fix panic when `SpanProcessor::on_end` calls `Context::current()` ([#3262][3262]).
   - Updated `SpanProcessor::on_end` documentation to clarify that `Context::current()` returns the parent context, not the span's context
 - Fix `traceparent` headers with unknown flags (e.g. W3C random-trace-id flag `0x02`) being incorrectly rejected. Unknown flags are now accepted and zeroed out as required by the W3C trace-context spec. [#3435][3435]
+- **Breaking** `InMemoryExporterError` has been removed and replaced by `OTelSdkError`, and a new `JaegerRemoteSamplerBuildError` introduced to replace last uses of `TraceError`. [#3458][3458]
 
 [3227]: https://github.com/open-telemetry/opentelemetry-rust/pull/3227
 [3277]: https://github.com/open-telemetry/opentelemetry-rust/pull/3277
@@ -43,6 +44,7 @@
 [3262]: https://github.com/open-telemetry/opentelemetry-rust/pull/3262
 [3407]: https://github.com/open-telemetry/opentelemetry-rust/pull/3407
 [3435]: https://github.com/open-telemetry/opentelemetry-rust/issues/3435
+[3458]: https://github.com/open-telemetry/opentelemetry-rust/pull/3458
 
 - "spec_unstable_logs_enabled" feature flag is removed. The capability (and the
   backing specification) is now stable and is enabled by default.

opentelemetry-sdk/src/error.rs

@@ -41,5 +41,12 @@ pub enum OTelSdkError {
     InternalFailure(String),
 }
 
+#[cfg(any(feature = "testing", test))]
+impl<T> From<std::sync::PoisonError<T>> for OTelSdkError {
+    fn from(err: std::sync::PoisonError<T>) -> Self {
+        OTelSdkError::InternalFailure(format!("Mutex poison error: {err}"))
+    }
+}
+
 /// A specialized `Result` type for Shutdown operations.
 pub type OTelSdkResult = Result<(), OTelSdkError>;

opentelemetry-sdk/src/lib.rs

@@ -196,24 +196,3 @@ pub use resource::Resource;
 
 pub mod error;
 pub use error::ExportError;
-
-#[cfg(any(feature = "testing", test))]
-#[derive(thiserror::Error, Debug)]
-/// Errors that can occur during when returning telemetry from InMemoryLogExporter
-pub enum InMemoryExporterError {
-    /// Operation failed due to an internal error.
-    ///
-    /// The error message is intended for logging purposes only and should not
-    /// be used to make programmatic decisions. It is implementation-specific
-    /// and subject to change without notice. Consumers of this error should not
-    /// rely on its content beyond logging.
-    #[error("Unable to obtain telemetry. Reason: {0}")]
-    InternalFailure(String),
-}
-
-#[cfg(any(feature = "testing", test))]
-impl<T> From<std::sync::PoisonError<T>> for InMemoryExporterError {
-    fn from(err: std::sync::PoisonError<T>) -> Self {
-        InMemoryExporterError::InternalFailure(format!("Mutex poison error: {err}"))
-    }
-}

opentelemetry-sdk/src/logs/in_memory_exporter.rs

@@ -1,7 +1,6 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::logs::SdkLogRecord;
 use crate::logs::{LogBatch, LogExporter};
-use crate::InMemoryExporterError;
 use crate::Resource;
 use opentelemetry::InstrumentationScope;
 use std::borrow::Cow;
@@ -149,6 +148,10 @@ impl InMemoryLogExporter {
 
     /// Returns the logs emitted via Logger as a vector of `LogDataWithResource`.
     ///
+    /// # Errors
+    ///
+    /// Returns an `OTelSdkError`.
+    ///
     /// # Example
     ///
     /// ```
@@ -158,9 +161,9 @@ impl InMemoryLogExporter {
     /// let emitted_logs = exporter.get_emitted_logs().unwrap();
     /// ```
     ///
-    pub fn get_emitted_logs(&self) -> Result<Vec<LogDataWithResource>, InMemoryExporterError> {
-        let logs_guard = self.logs.lock().map_err(InMemoryExporterError::from)?;
-        let resource_guard = self.resource.lock().map_err(InMemoryExporterError::from)?;
+    pub fn get_emitted_logs(&self) -> Result<Vec<LogDataWithResource>, OTelSdkError> {
+        let logs_guard = self.logs.lock().map_err(OTelSdkError::from)?;
+        let resource_guard = self.resource.lock().map_err(OTelSdkError::from)?;
         let logs: Vec<LogDataWithResource> = logs_guard
             .iter()
             .map(|log_data| LogDataWithResource {

opentelemetry-sdk/src/metrics/in_memory_exporter.rs

@@ -4,7 +4,6 @@ use crate::metrics::data::{
 };
 use crate::metrics::exporter::PushMetricExporter;
 use crate::metrics::Temporality;
-use crate::InMemoryExporterError;
 use std::collections::VecDeque;
 use std::fmt;
 use std::sync::{Arc, Mutex};
@@ -136,7 +135,7 @@ impl InMemoryMetricExporter {
     ///
     /// # Errors
     ///
-    /// Returns a `MetricError` if the internal lock cannot be acquired.
+    /// Returns an `OTelSdkError`.
     ///
     /// # Example
     ///
@@ -146,12 +145,12 @@ impl InMemoryMetricExporter {
     /// let exporter = InMemoryMetricExporter::default();
     /// let finished_metrics = exporter.get_finished_metrics().unwrap();
     /// ```
-    pub fn get_finished_metrics(&self) -> Result<Vec<ResourceMetrics>, InMemoryExporterError> {
+    pub fn get_finished_metrics(&self) -> Result<Vec<ResourceMetrics>, OTelSdkError> {
         let metrics = self
             .metrics
             .lock()
             .map(|metrics_guard| metrics_guard.iter().map(Self::clone_metrics).collect())
-            .map_err(InMemoryExporterError::from)?;
+            .map_err(OTelSdkError::from)?;
         Ok(metrics)
     }
 

opentelemetry-sdk/src/trace/error.rs

@@ -1,7 +1,6 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::resource::Resource;
 use crate::trace::{SpanData, SpanExporter};
-use crate::InMemoryExporterError;
 use std::sync::{atomic::AtomicBool, Arc, Mutex};
 use std::time::Duration;
 
@@ -118,7 +117,7 @@ impl InMemorySpanExporter {
     ///
     /// # Errors
     ///
-    /// Returns a `TraceError` if the internal lock cannot be acquired.
+    /// Returns an `OTelSdkError`.
     ///
     /// # Example
     ///
@@ -128,12 +127,12 @@ impl InMemorySpanExporter {
     /// let exporter = InMemorySpanExporter::default();
     /// let finished_spans = exporter.get_finished_spans().unwrap();
     /// ```
-    pub fn get_finished_spans(&self) -> Result<Vec<SpanData>, InMemoryExporterError> {
+    pub fn get_finished_spans(&self) -> Result<Vec<SpanData>, OTelSdkError> {
         let spans = self
             .spans
             .lock()
             .map(|spans_guard| spans_guard.iter().cloned().collect())
-            .map_err(InMemoryExporterError::from)?;
+            .map_err(OTelSdkError::from)?;
         Ok(spans)
     }
 

opentelemetry-sdk/src/trace/in_memory_exporter.rs

@@ -7,7 +7,6 @@
 //!   current operation execution.
 //! * The [`SdkTracerProvider`] struct which configures and produces [`SdkTracer`]s.
 mod config;
-mod error;
 mod events;
 mod export;
 mod id_generator;
@@ -23,7 +22,6 @@ pub mod span_processor_with_async_runtime;
 mod tracer;
 
 pub use config::Config;
-pub use error::{TraceError, TraceResult};
 pub use events::SpanEvents;
 pub use export::{SpanData, SpanExporter};
 

opentelemetry-sdk/src/trace/mod.rs

@@ -1,5 +1,4 @@
 use crate::runtime::{to_interval_stream, RuntimeChannel};
-use crate::trace::error::TraceError;
 use crate::trace::sampler::jaeger_remote::remote::SamplingStrategyResponse;
 use crate::trace::sampler::jaeger_remote::sampling_strategy::Inner;
 use crate::trace::{Sampler, SamplingResult, ShouldSample};
@@ -11,9 +10,17 @@ use opentelemetry_http::HttpClient;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
+use thiserror::Error;
 
 const DEFAULT_REMOTE_SAMPLER_ENDPOINT: &str = "http://localhost:5778/sampling";
 
+#[derive(Error, Debug)]
+#[non_exhaustive]
+pub enum JaegerRemoteSamplerBuildError {
+    #[error("Invalid endpoint. Unable to create JaegerRemoteSampler.")]
+    InvalidEndpoint(String),
+}
+
 /// Builder for [`JaegerRemoteSampler`].
 /// See [Sampler::jaeger_remote] for details.
 #[derive(Debug)]
@@ -100,9 +107,9 @@ where
     ///
     /// - the endpoint provided is empty.
     /// - the service name provided is empty.
-    pub fn build(self) -> Result<Sampler, TraceError> {
+    pub fn build(self) -> Result<Sampler, JaegerRemoteSamplerBuildError> {
         let endpoint = Self::get_endpoint(&self.endpoint, &self.service_name)
-            .map_err(|err_str| TraceError::Other(err_str.into()))?;
+            .map_err(JaegerRemoteSamplerBuildError::InvalidEndpoint)?;
 
         Ok(Sampler::JaegerRemote(JaegerRemoteSampler::new(
             self.runtime,

opentelemetry-sdk/src/trace/sampler/jaeger_remote/sampler.rs

@@ -23,7 +23,7 @@
 //! ```no_run
 //! use opentelemetry::global;
 //! use opentelemetry::trace::Tracer;
-//! use opentelemetry_sdk::{trace::{SdkTracerProvider, TraceError}, Resource};
+//! use opentelemetry_sdk::{trace::SdkTracerProvider, Resource};
 //! use opentelemetry_zipkin::{ExporterBuildError,ZipkinExporter};
 //!
 //! fn main() -> Result<(), ExporterBuildError> {
@@ -114,7 +114,7 @@
 //!
 //! ```no_run
 //! use opentelemetry::{global, InstrumentationScope, KeyValue, trace::Tracer};
-//! use opentelemetry_sdk::{trace::{self, RandomIdGenerator, Sampler, TraceError}, Resource};
+//! use opentelemetry_sdk::{trace::{self, RandomIdGenerator, Sampler}, Resource};
 //! use opentelemetry_http::{HttpClient, HttpError};
 //! use opentelemetry_zipkin::{ExporterBuildError, ZipkinExporter};
 //! use async_trait::async_trait;