initial commit

Author: lalitb

opentelemetry/src/global/error_handler.rs renamed to opentelemetry-sdk/src/error.rs

@@ -1,13 +1,12 @@
 use std::sync::PoisonError;
-use std::sync::RwLock;
 
 #[cfg(feature = "logs")]
 use crate::logs::LogError;
 #[cfg(feature = "metrics")]
 use crate::metrics::MetricError;
-use crate::propagation::PropagationError;
+use opentelemetry::propagation::PropagationError;
 #[cfg(feature = "trace")]
-use crate::trace::TraceError;
+use opentelemetry::trace::TraceError;
 
 /// Wrapper for error from both tracing and metrics part of open telemetry.
 #[derive(thiserror::Error, Debug)]

opentelemetry-sdk/src/export/logs/mod.rs

@@ -1,10 +1,10 @@
 //! Log exporters
 use crate::logs::LogRecord;
+use crate::logs::{LogError, LogResult};
 use crate::Resource;
 use async_trait::async_trait;
 #[cfg(feature = "logs_level_enabled")]
 use opentelemetry::logs::Severity;
-use opentelemetry::logs::{LogError, LogResult};
 use opentelemetry::InstrumentationScope;
 use std::fmt::Debug;
 

opentelemetry-sdk/src/export/mod.rs

@@ -8,4 +8,8 @@ pub mod logs;
 #[cfg_attr(docsrs, doc(cfg(feature = "trace")))]
 pub mod trace;
 
-pub use opentelemetry::ExportError;
+/// Marker trait for errors returned by exporters
+pub trait ExportError: std::error::Error + Send + Sync + 'static {
+    /// The name of exporter that returned this error
+    fn exporter_name(&self) -> &'static str;
+}

opentelemetry-sdk/src/lib.rs

@@ -148,3 +148,5 @@ pub mod util;
 
 #[doc(inline)]
 pub use resource::Resource;
+
+pub mod error;

opentelemetry-sdk/src/logs/error.rs

@@ -0,0 +1,63 @@
+use crate::export::ExportError;
+
+use std::{sync::PoisonError, time::Duration};
+use thiserror::Error;
+
+/// Describe the result of operations in log SDK.
+pub type LogResult<T> = Result<T, LogError>;
+
+#[derive(Error, Debug)]
+#[non_exhaustive]
+/// Errors returned by the log SDK.
+pub enum LogError {
+    /// Export failed with the error returned by the exporter.
+    #[error("Exporter {} encountered the following errors: {0}", .0.exporter_name())]
+    ExportFailed(Box<dyn ExportError>),
+
+    /// Export failed to finish after certain period and processor stopped the export.
+    #[error("Exporter timed out after {} seconds", .0.as_secs())]
+    ExportTimedOut(Duration),
+
+    /// Processor is already shutdown
+    #[error("{0} already shutdown")]
+    AlreadyShutdown(String),
+
+    /// Mutex lock poisoning
+    #[error("mutex lock poisioning for {0}")]
+    MutexPoisoned(String),
+
+    /// Other errors propagated from log SDK that weren't covered above.
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
+}
+
+impl<T> From<T> for LogError
+where
+    T: ExportError,
+{
+    fn from(err: T) -> Self {
+        LogError::ExportFailed(Box::new(err))
+    }
+}
+
+impl From<String> for LogError {
+    fn from(err_msg: String) -> Self {
+        LogError::Other(Box::new(Custom(err_msg)))
+    }
+}
+
+impl From<&'static str> for LogError {
+    fn from(err_msg: &'static str) -> Self {
+        LogError::Other(Box::new(Custom(err_msg.into())))
+    }
+}
+
+impl<T> From<PoisonError<T>> for LogError {
+    fn from(err: PoisonError<T>) -> Self {
+        LogError::Other(err.to_string().into())
+    }
+}
+/// Wrap type for string
+#[derive(Error, Debug)]
+#[error("{0}")]
+struct Custom(String);

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -1,11 +1,7 @@
 use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext};
 use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource};
-use opentelemetry::{
-    logs::{LogError, LogResult},
-    otel_debug,
-    trace::TraceContextExt,
-    Context, InstrumentationScope,
-};
+use crate::{logs::LogError, logs::LogResult};
+use opentelemetry::{otel_debug, trace::TraceContextExt, Context, InstrumentationScope};
 
 #[cfg(feature = "logs_level_enabled")]
 use opentelemetry::logs::Severity;

opentelemetry-sdk/src/logs/log_processor.rs

@@ -1,6 +1,6 @@
 use crate::{
     export::logs::{ExportResult, LogBatch, LogExporter},
-    logs::LogRecord,
+    logs::{LogError, LogRecord, LogResult},
     runtime::{RuntimeChannel, TrySend},
     Resource,
 };
@@ -11,10 +11,7 @@ use futures_util::{
 };
 #[cfg(feature = "logs_level_enabled")]
 use opentelemetry::logs::Severity;
-use opentelemetry::{
-    logs::{LogError, LogResult},
-    otel_debug, otel_error, otel_warn, InstrumentationScope,
-};
+use opentelemetry::{otel_debug, otel_error, otel_warn, InstrumentationScope};
 
 use std::sync::atomic::AtomicBool;
 use std::{cmp::min, env, sync::Mutex};

opentelemetry-sdk/src/logs/mod.rs

@@ -1,8 +1,10 @@
 //! # OpenTelemetry Log SDK
+mod error;
 mod log_emitter;
 mod log_processor;
 pub(crate) mod record;
 
+pub use error::{LogError, LogResult};
 pub use log_emitter::{Builder, Logger, LoggerProvider};
 pub use log_processor::{
     BatchConfig, BatchConfigBuilder, BatchLogProcessor, BatchLogProcessorBuilder, LogProcessor,

opentelemetry-sdk/src/metrics/aggregation.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 
 use crate::metrics::internal::{EXPO_MAX_SCALE, EXPO_MIN_SCALE};
-use opentelemetry::metrics::{MetricError, MetricResult};
+use crate::metrics::{MetricError, MetricResult};
 
 /// The way recorded measurements are summarized.
 #[derive(Clone, Debug, PartialEq)]

opentelemetry-sdk/src/metrics/error.rs

@@ -0,0 +1,40 @@
+use std::result;
+use std::sync::PoisonError;
+use thiserror::Error;
+
+use crate::export::ExportError;
+
+/// A specialized `Result` type for metric operations.
+pub type MetricResult<T> = result::Result<T, MetricError>;
+
+/// Errors returned by the metrics API.
+#[derive(Error, Debug)]
+#[non_exhaustive]
+pub enum MetricError {
+    /// Other errors not covered by specific cases.
+    #[error("Metrics error: {0}")]
+    Other(String),
+    /// Invalid configuration
+    #[error("Config error {0}")]
+    Config(String),
+    /// Fail to export metrics
+    #[error("Metrics exporter {} failed with {0}", .0.exporter_name())]
+    ExportErr(Box<dyn ExportError>),
+    /// Invalid instrument configuration such invalid instrument name, invalid instrument description, invalid instrument unit, etc.
+    /// See [spec](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/api.md#general-characteristics)
+    /// for full list of requirements.
+    #[error("Invalid instrument configuration: {0}")]
+    InvalidInstrumentConfiguration(&'static str),
+}
+
+impl<T: ExportError> From<T> for MetricError {
+    fn from(err: T) -> Self {
+        MetricError::ExportErr(Box::new(err))
+    }
+}
+
+impl<T> From<PoisonError<T>> for MetricError {
+    fn from(err: PoisonError<T>) -> Self {
+        MetricError::Other(err.to_string())
+    }
+}