everywhere

Author: cijothomas

opentelemetry-sdk/src/metrics/manual_reader.rs

@@ -111,9 +111,10 @@ impl MetricReader for ManualReader {
 
     /// Closes any connections and frees any resources used by the reader.
     fn shutdown(&self) -> OTelSdkResult {
-        let mut inner = self.inner.lock().map_err(|e| {
-            OTelSdkError::InternalFailure(format!("Failed to acquire lock: {}", e))
-        })?;
+        let mut inner = self
+            .inner
+            .lock()
+            .map_err(|e| OTelSdkError::InternalFailure(format!("Failed to acquire lock: {}", e)))?;
 
         // Any future call to collect will now return an error.
         inner.sdk_producer = None;

opentelemetry-sdk/src/metrics/periodic_reader_with_async_runtime.rs

@@ -15,7 +15,7 @@ use opentelemetry::{otel_debug, otel_error};
 
 use crate::runtime::Runtime;
 use crate::{
-    error::{ShutdownError, ShutdownResult},
+    error::{OtelSdkError, OtelSdkResult},
     metrics::{exporter::PushMetricExporter, reader::SdkProducer, MetricError, MetricResult},
     Resource,
 };
@@ -217,7 +217,7 @@ struct PeriodicReaderInner {
 enum Message {
     Export,
     Flush(oneshot::Sender<MetricResult<()>>),
-    Shutdown(oneshot::Sender<ShutdownResult>),
+    Shutdown(oneshot::Sender<OtelSdkResult>),
 }
 
 enum ProducerOrWorker {
@@ -297,7 +297,7 @@ impl<RT: Runtime> PeriodicReaderWorker<RT> {
                 let res = self.collect_and_export().await;
                 let _ = self.reader.exporter.shutdown();
                 if let Err(send_error) =
-                    ch.send(res.map_err(|e| ShutdownError::InternalFailure(e.to_string())))
+                    ch.send(res.map_err(|e| OtelSdkError::InternalFailure(e.to_string())))
                 {
                     otel_debug!(
                         name: "PeriodicReader.Shutdown.SendResultError",
@@ -378,30 +378,30 @@ impl MetricReader for PeriodicReader {
             .and_then(|res| res)
     }
 
-    fn shutdown(&self) -> ShutdownResult {
+    fn shutdown(&self) -> OtelSdkResult {
         let mut inner = self
             .inner
             .lock()
-            .map_err(|e| ShutdownError::InternalFailure(e.to_string()))?;
+            .map_err(|e| OtelSdkError::InternalFailure(e.to_string()))?;
         if inner.is_shutdown {
-            return Err(ShutdownError::AlreadyShutdown);
+            return Err(OtelSdkError::AlreadyShutdown);
         }
 
         let (sender, receiver) = oneshot::channel();
         inner
             .message_sender
             .try_send(Message::Shutdown(sender))
-            .map_err(|e| ShutdownError::InternalFailure(e.to_string()))?;
+            .map_err(|e| OtelSdkError::InternalFailure(e.to_string()))?;
         drop(inner); // don't hold lock when blocking on future
 
         let shutdown_result = futures_executor::block_on(receiver)
-            .map_err(|err| ShutdownError::InternalFailure(err.to_string()))?;
+            .map_err(|err| OtelSdkError::InternalFailure(err.to_string()))?;
 
         // Acquire the lock again to set the shutdown flag
         let mut inner = self
             .inner
             .lock()
-            .map_err(|e| ShutdownError::InternalFailure(e.to_string()))?;
+            .map_err(|e| OtelSdkError::InternalFailure(e.to_string()))?;
         inner.is_shutdown = true;
 
         shutdown_result