Global error handler cleanup - Trace SDK

opentelemetry-sdk/src/trace/config.rs

@@ -4,7 +4,7 @@
 //! can be set for the default OpenTelemetry limits and Sampler.
 use crate::trace::{span_limit::SpanLimits, IdGenerator, RandomIdGenerator, Sampler, ShouldSample};
 use crate::Resource;
-use opentelemetry::global::{handle_error, Error};
+use opentelemetry::{otel_debug, otel_warn};
 use std::borrow::Cow;
 use std::env;
 use std::str::FromStr;
@@ -129,9 +129,9 @@
                     if let Some(r) = ratio {
                         Box::new(Sampler::TraceIdRatioBased(r))
                     } else {
-                        handle_error(
-                            Error::Other(String::from(
-                                "Missing or invalid OTEL_TRACES_SAMPLER_ARG value. Falling back to default: 1.0"))
+                        otel_warn!(
+                            name: "TracesSampler.TraceIdRatio.Error",
+                            message= "Missing or invalid OTEL_TRACES_SAMPLER_ARG env variable. Falling back to default: 1.0"
                         );
                         Box::new(Sampler::TraceIdRatioBased(1.0))
                     }
@@ -149,37 +149,42 @@
                             r,
                         ))))
                     } else {
-                        handle_error(
-                            Error::Other(String::from(
-                            "Missing or invalid OTEL_TRACES_SAMPLER_ARG value. Falling back to default: 1.0"
-                        )));
+                        otel_warn!(
+                            name: "TracesSampler.ParentBasedTraceIdRatio.Error",
+                            message = "Missing or invalid OTEL_TRACES_SAMPLER_ARG env variable. Falling back to default: 1.0"
+                        );
                         Box::new(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(
                             1.0,
                         ))))
                     }
                 }
                 "parentbased_jaeger_remote" => {
-                    handle_error(
-                        Error::Other(String::from(
-                        "Unimplemented parentbased_jaeger_remote sampler. Falling back to default: parentbased_always_on"
-                    )));
+                    otel_debug!(
+                        name: "TracesSampler.ParentBasedJaegerRemote.Error",
+                        message = "Unimplemented parentbased_jaeger_remote sampler. Falling back to default: parentbased_always_on"
+                    );
                     Box::new(Sampler::ParentBased(Box::new(Sampler::AlwaysOn)))
                 }
                 "jaeger_remote" => {
-                    handle_error(
-                        Error::Other(String::from("Unimplemented jaeger_remote sampler. Falling back to default: parentbased_always_on")));
+                    otel_debug!(
+                        name: "TracesSampler.JaegerRemote.Error",
+                        message = "Unimplemented jaeger_remote sampler. Falling back to default: parentbased_always_on"
+                    );
                     Box::new(Sampler::ParentBased(Box::new(Sampler::AlwaysOn)))
                 }
                 "xray" => {
-                    handle_error(
-                        Error::Other(String::from("Unimplemented xray sampler. Falling back to default: parentbased_always_on")));
+                    otel_debug!(
+                        name: "TracesSampler.Xray.Error",
+                        message = "Unimplemented xray sampler. Falling back to default: parentbased_always_on"
+                    );
                     Box::new(Sampler::ParentBased(Box::new(Sampler::AlwaysOn)))
                 }
                 s => {
-                    handle_error(
-                        Error::Other(format!("Unrecognised OTEL_TRACES_SAMPLER value: {}. Falling back to default: parentbased_always_on",
-                        s
-                    )));
+                    otel_warn!(
+                        name: "TracesSampler.Unknown.Error",
+                        message = "Unrecognised OTEL_TRACES_SAMPLER env variable. Falling back to default: parentbased_always_on",
+                        sampler = s
+                    );
                     Box::new(Sampler::ParentBased(Box::new(Sampler::AlwaysOn)))
                 }
             }

opentelemetry-sdk/src/trace/span_processor.rs

@@ -45,7 +45,7 @@
     stream::{self, FusedStream, FuturesUnordered},
     StreamExt as _,
 };
-use opentelemetry::global;
+use opentelemetry::{otel_debug, otel_error};
 use opentelemetry::{
     trace::{TraceError, TraceResult},
     Context,
@@ -134,7 +134,10 @@
             .and_then(|mut exporter| futures_executor::block_on(exporter.export(vec![span])));
 
         if let Err(err) = result {
-            global::handle_error(err);
+            otel_error!(
+                name: "SimpleProcessor.OnEnd.Error",
+                reason = format!("{:?}", err)
+            );
         }
     }
 
@@ -246,7 +249,10 @@
         let result = self.message_sender.try_send(BatchMessage::ExportSpan(span));
 
         if let Err(err) = result {
-            global::handle_error(TraceError::Other(err.into()));
+            otel_error!(
+                name: "BatchProcessor.OnEnd.Error",
+                reason = format!("{:?}", TraceError::Other(err.into()))
+            );
         }
     }
 
@@ -313,14 +319,21 @@
             let result = export_task.await;
 
             if let Some(channel) = res_channel {
+                // If a response channel is provided, attempt to send the export result through it.
                 if let Err(result) = channel.send(result) {
-                    global::handle_error(TraceError::from(format!(
-                        "failed to send flush result: {:?}",
-                        result
-                    )));
+                    otel_debug!(
+                        name: "BatchSpanProcessor.Flush.SendResultError",
+                        reason = format!("{:?}", result)
+                    );
                 }
             } else if let Err(err) = result {
-                global::handle_error(err);
+                // If no channel is provided and the export operation encountered an error,
+                // log the error directly here.
+                otel_error!(
+                    name: "BatchSpanProcessor.Flush.ExportError",
+                    reason = format!("{:?}", err),
+                    message = "Failed during the export process"
+                );
             }
 
             Ok(())
@@ -354,7 +367,10 @@
                     let export_task = self.export();
                     let task = async move {
                         if let Err(err) = export_task.await {
-                            global::handle_error(err);
+                            otel_error!(
+                                name: "BatchSpanProcessor.Export.Error",
+                                reason = format!("{}", err)
+                            );
                         }
 
                         Ok(())