inmemory error variant

Author: cijothomas

opentelemetry-sdk/src/lib.rs

@@ -146,3 +146,24 @@ 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,6 +1,7 @@
 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;
@@ -155,9 +156,9 @@ impl InMemoryLogExporter {
     /// let emitted_logs = exporter.get_emitted_logs().unwrap();
     /// ```
     ///
-    pub fn get_emitted_logs(&self) -> Result<Vec<LogDataWithResource>, String> {
-        let logs_guard = self.logs.lock().map_err(|e| e.to_string())?;
-        let resource_guard = self.resource.lock().map_err(|e| e.to_string())?;
+    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)?;
         let logs: Vec<LogDataWithResource> = logs_guard
             .iter()
             .map(|log_data| LogDataWithResource {

opentelemetry-sdk/src/metrics/in_memory_exporter.rs

@@ -3,6 +3,7 @@ use crate::metrics::data::{self, Gauge, Sum};
 use crate::metrics::data::{Histogram, Metric, ResourceMetrics, ScopeMetrics};
 use crate::metrics::exporter::PushMetricExporter;
 use crate::metrics::Temporality;
+use crate::InMemoryExporterError;
 use std::collections::VecDeque;
 use std::fmt;
 use std::sync::{Arc, Mutex};
@@ -141,11 +142,13 @@ impl InMemoryMetricExporter {
     /// let exporter = InMemoryMetricExporter::default();
     /// let finished_metrics = exporter.get_finished_metrics().unwrap();
     /// ```
-    pub fn get_finished_metrics(&self) -> Result<Vec<ResourceMetrics>, String> {
-        self.metrics
+    pub fn get_finished_metrics(&self) -> Result<Vec<ResourceMetrics>, InMemoryExporterError> {
+        let metrics = self
+            .metrics
             .lock()
             .map(|metrics_guard| metrics_guard.iter().map(Self::clone_metrics).collect())
-            .map_err(|e| e.to_string())
+            .map_err(InMemoryExporterError::from)?;
+        Ok(metrics)
     }
 
     /// Clears the internal storage of finished metrics.

opentelemetry-sdk/src/trace/in_memory_exporter.rs

@@ -1,6 +1,7 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
 use crate::resource::Resource;
 use crate::trace::{SpanData, SpanExporter};
+use crate::InMemoryExporterError;
 use std::sync::{Arc, Mutex};
 
 /// An in-memory span exporter that stores span data in memory.
@@ -103,11 +104,13 @@ impl InMemorySpanExporter {
     /// let exporter = InMemorySpanExporter::default();
     /// let finished_spans = exporter.get_finished_spans().unwrap();
     /// ```
-    pub fn get_finished_spans(&self) -> Result<Vec<SpanData>, String> {
-        self.spans
+    pub fn get_finished_spans(&self) -> Result<Vec<SpanData>, InMemoryExporterError> {
+        let spans = self
+            .spans
             .lock()
             .map(|spans_guard| spans_guard.iter().cloned().collect())
-            .map_err(|e| e.to_string())
+            .map_err(InMemoryExporterError::from)?;
+        Ok(spans)
     }
 
     /// Clears the internal storage of finished spans.