Global error handler cleanup - Metrics SDK

opentelemetry-sdk/src/metrics/internal/exponential_histogram.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, f64::consts::LOG2_E, sync::Mutex, time::SystemTime};
 
 use once_cell::sync::Lazy;
-use opentelemetry::{metrics::MetricsError, KeyValue};
+use opentelemetry::{otel_error, KeyValue};
 
 use crate::{
     metrics::data::{self, Aggregation, Temporality},
@@ -100,9 +100,15 @@
             if (self.scale - scale_delta as i8) < EXPO_MIN_SCALE {
                 // With a scale of -10 there is only two buckets for the whole range of f64 values.
                 // This can only happen if there is a max size of 1.
-                opentelemetry::global::handle_error(MetricsError::Other(
-                    "exponential histogram scale underflow".into(),
-                ));
+                otel_error!(
+                    name: "ExponentialHistogramDataPoint.Scale.Underflow",
+                    current_scale = self.scale,
+                    scale_delta = scale_delta,
+                    max_size = self.max_size,
+                    min_scale = EXPO_MIN_SCALE,
+                    record_min_max = self.record_min_max,
+                    record_sum = self.record_sum
+                );
                 return;
             }
             // Downscale

opentelemetry-sdk/src/metrics/internal/mod.rs

@@ -17,7 +17,7 @@
 pub(crate) use exponential_histogram::{EXPO_MAX_SCALE, EXPO_MIN_SCALE};
 use once_cell::sync::Lazy;
 use opentelemetry::metrics::MetricsError;
-use opentelemetry::{global, otel_warn, KeyValue};
+use opentelemetry::{otel_error, KeyValue};
 
 use crate::metrics::AttributeSet;
 
@@ -146,9 +146,8 @@
             let new_tracker = AU::new_atomic_tracker(self.buckets_count);
             O::update_tracker(&new_tracker, measurement, index);
             trackers.insert(STREAM_OVERFLOW_ATTRIBUTES.clone(), Arc::new(new_tracker));
-            global::handle_error(MetricsError::Other("Warning: Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged.".into()));
-            otel_warn!( name: "ValueMap.measure",
-                message = "Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged."
+            otel_error!( name: "ValueMap.Measure.Overflow",
+                error = MetricsError::Other("Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric until next collect will not be logged.".into())
             );
         }
     }

opentelemetry-sdk/src/metrics/manual_reader.rs

@@ -4,8 +4,8 @@
 };
 
 use opentelemetry::{
-    global,
     metrics::{MetricsError, Result},
+    otel_error,
 };
 
 use super::{
@@ -84,9 +84,7 @@
             if inner.sdk_producer.is_none() {
                 inner.sdk_producer = Some(pipeline);
             } else {
-                global::handle_error(MetricsError::Config(
-                    "duplicate reader registration, did not register manual reader".into(),
-                ))
+                otel_error!(name: "ManualReader.RegisterPipeline.DuplicateRegistration");
             }
         });
     }

opentelemetry-sdk/src/metrics/meter.rs

@@ -2,13 +2,13 @@
 use std::{borrow::Cow, sync::Arc};
 
 use opentelemetry::{
-    global,
     metrics::{
         noop::{NoopAsyncInstrument, NoopSyncInstrument},
         AsyncInstrumentBuilder, Counter, Gauge, Histogram, HistogramBuilder, InstrumentBuilder,
         InstrumentProvider, MetricsError, ObservableCounter, ObservableGauge,
         ObservableUpDownCounter, Result, UpDownCounter,
     },
+    otel_error,
 };
 
 use crate::instrumentation::Scope;
@@ -74,7 +74,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateCounter.ValidationError", error = err);
             return Ok(Counter::new(Arc::new(NoopSyncInstrument::new())));
         }
 
@@ -90,7 +90,7 @@
         {
             Ok(counter) => Ok(counter),
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(name: "SdkMeter.CreateCounter.Error", error = err);
                 Ok(Counter::new(Arc::new(NoopSyncInstrument::new())))
             }
         }
@@ -106,7 +106,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateObservableCounter.ValidationError", error = err);
             return Ok(ObservableCounter::new(Arc::new(NoopAsyncInstrument::new())));
         }
 
@@ -119,6 +119,7 @@
         )?;
 
         if ms.is_empty() {
+            otel_error!(name: "SdkMeter.CreateObservableCounter.Error", error = MetricsError::Other("no measures found".into()));
             return Ok(ObservableCounter::new(Arc::new(NoopAsyncInstrument::new())));
         }
 
@@ -143,7 +144,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateObservableUpDownCounter.ValidationError", error = err);
             return Ok(ObservableUpDownCounter::new(Arc::new(
                 NoopAsyncInstrument::new(),
             )));
@@ -158,6 +159,7 @@
         )?;
 
         if ms.is_empty() {
+            otel_error!(name: "SdkMeter.CreateObservableUpDownCounter.Error", error = MetricsError::Other("no measures found".into()));
             return Ok(ObservableUpDownCounter::new(Arc::new(
                 NoopAsyncInstrument::new(),
             )));
@@ -184,7 +186,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateObservableGauge.ValidationError", error = err);
             return Ok(ObservableGauge::new(Arc::new(NoopAsyncInstrument::new())));
         }
 
@@ -197,6 +199,7 @@
         )?;
 
         if ms.is_empty() {
+            otel_error!(name: "SdkMeter.CreateObservableGauge.Error", error = MetricsError::Other("no measures found".into()));
             return Ok(ObservableGauge::new(Arc::new(NoopAsyncInstrument::new())));
         }
 
@@ -221,7 +224,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateUpDownCounter.ValidationError", error = err);
             return Ok(UpDownCounter::new(Arc::new(NoopSyncInstrument::new())));
         }
 
@@ -237,7 +240,7 @@
         {
             Ok(updown_counter) => Ok(updown_counter),
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(name: "SdkMeter.CreateUpDownCounter.Error", error = err);
                 Ok(UpDownCounter::new(Arc::new(NoopSyncInstrument::new())))
             }
         }
@@ -253,7 +256,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateGauge.ValidationError", error = err);
             return Ok(Gauge::new(Arc::new(NoopSyncInstrument::new())));
         }
 
@@ -269,7 +272,7 @@
         {
             Ok(gauge) => Ok(gauge),
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(name: "SdkMeter.CreateGauge.Error", error = err);
                 Ok(Gauge::new(Arc::new(NoopSyncInstrument::new())))
             }
         }
@@ -285,7 +288,7 @@
     {
         let validation_result = validate_instrument_config(builder.name.as_ref(), &builder.unit);
         if let Err(err) = validation_result {
-            global::handle_error(err);
+            otel_error!(name: "SdkMeter.CreateHistogram.ValidationError", error = err);
             return Ok(Histogram::new(Arc::new(NoopSyncInstrument::new())));
         }
 
@@ -301,7 +304,7 @@
         {
             Ok(histogram) => Ok(histogram),
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(name: "SdkMeter.CreateHistogram.Error", error = err);
                 Ok(Histogram::new(Arc::new(NoopSyncInstrument::new())))
             }
         }

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -8,9 +8,8 @@
 };
 
 use opentelemetry::{
-    global,
     metrics::{noop::NoopMeter, Meter, MeterProvider, MetricsError, Result},
-    KeyValue,
+    otel_error, KeyValue,
 };
 
 use crate::{instrumentation::Scope, Resource};
@@ -137,7 +136,7 @@
         // shutdown(), then we don't need to call shutdown again.
         if !self.is_shutdown.load(Ordering::Relaxed) {
             if let Err(err) = self.shutdown() {
-                global::handle_error(err);
+                otel_error!(name: "SdkMeterProvider.Drop.ShutdownError", error = err);
             }
         }
     }

opentelemetry-sdk/src/metrics/pipeline.rs

@@ -6,9 +6,8 @@
 };
 
 use opentelemetry::{
-    global,
     metrics::{MetricsError, Result},
-    KeyValue,
+    otel_warn, KeyValue,
 };
 
 use crate::{
@@ -414,15 +413,13 @@
                 if existing == id {
                     return;
                 }
-
-                global::handle_error(MetricsError::Other(format!(
-                    "duplicate metric stream definitions, names: ({} and {}), descriptions: ({} and {}), kinds: ({:?} and {:?}), units: ({:?} and {:?}), and numbers: ({} and {})",
-                    existing.name, id.name,
-                    existing.description, id.description,
-                    existing.kind, id.kind,
-                    existing.unit, id.unit,
-                    existing.number, id.number,
-               )))
+                otel_warn!(name: "InstrumentSync.AddSync.DuplicateMetricStreamDefinitions",
+                    name = id.name.clone(),
+                    description = id.description.clone(),
+                    kind = id.kind,
+                    unit = id.unit.clone(),
+                    number = id.number.clone(),
+                );
             }
         }
     }

opentelemetry-sdk/src/metrics/view.rs

@@ -1,8 +1,8 @@
 use super::instrument::{Instrument, Stream};
 use glob::Pattern;
 use opentelemetry::{
-    global,
     metrics::{MetricsError, Result},
+    otel_error,
 };
 
 fn empty_view(_inst: &Instrument) -> Option<Stream> {
@@ -102,19 +102,23 @@
 /// ```
 pub fn new_view(criteria: Instrument, mask: Stream) -> Result<Box<dyn View>> {
     if criteria.is_empty() {
-        global::handle_error(MetricsError::Config(format!(
-            "no criteria provided, dropping view. mask: {mask:?}"
-        )));
+        otel_error!(name: "CreateView.ValidationError", error = MetricsError::Config(
+            "no criteria provided, dropping view".to_string()),
+            criteria = criteria,
+            mask = mask
+        );
         return Ok(Box::new(empty_view));
     }
     let contains_wildcard = criteria.name.contains(['*', '?']);
     let err_msg_criteria = criteria.clone();
 
     let match_fn: Box<dyn Fn(&Instrument) -> bool + Send + Sync> = if contains_wildcard {
         if mask.name != "" {
-            global::handle_error(MetricsError::Config(format!(
-				"name replacement for multiple instruments, dropping view, criteria: {criteria:?}, mask: {mask:?}"
-			)));
+            otel_error!(name: "CreateView.ValidationError", error = MetricsError::Config(
+                "name replacement for wildcard instrument, dropping view".to_string()),
+                criteria = criteria,
+                mask = mask
+            );
             return Ok(Box::new(empty_view));
         }
 
@@ -138,10 +142,12 @@
         match ma.validate() {
             Ok(_) => agg = Some(ma.clone()),
             Err(err) => {
-                global::handle_error(MetricsError::Other(format!(
-                    "{}, proceeding as if view did not exist. criteria: {:?}, mask: {:?}",
-                    err, err_msg_criteria, mask
-                )));
+                otel_error!(name: "CreateView.ValidationError",
+                    error = MetricsError::Config("invalid aggregation, dropping view".to_string()),
+                    criteria = err_msg_criteria,
+                    mask = mask,
+                    error = err
+                );
                 return Ok(Box::new(empty_view));
             }
         }

opentelemetry/src/global/internal_logging.rs

@@ -50,11 +50,29 @@ macro_rules! otel_warn {
         {
             tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), "");
         }
+        #[cfg(not(feature = "internal-logs"))]
+        {
+            #[allow(unused_variables)]
+            {
+
+            }
+        }
     };
     (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => {
         #[cfg(feature = "internal-logs")]
         {
-            tracing::warn!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, "");
+            tracing::warn!(name: $name,
+                target: env!("CARGO_PKG_NAME"),
+                $($key = {
+                        $crate::format_value!($value)
+                }),+,
+                ""
+        )        }
+        #[cfg(not(feature = "internal-logs"))]
+        {
+            {
+                let _ = ($name, $($value),+);
+            }
         }
     };
 }
@@ -104,11 +122,34 @@ macro_rules! otel_error {
         {
             tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), "");
         }
+        #[allow(unused_variables)]
+        {
+
+        }
     };
     (name: $name:expr, $($key:ident = $value:expr),+ $(,)?) => {
         #[cfg(feature = "internal-logs")]
         {
-            tracing::error!(name: $name, target: env!("CARGO_PKG_NAME"), $($key = $value),+, "");
+            tracing::error!(name: $name,
+                target: env!("CARGO_PKG_NAME"),
+                $($key = {
+                        $crate::format_value!($value)
+                }),+,
+                ""
+        )        }
+        #[cfg(not(feature = "internal-logs"))]
+        {
+            {
+                let _ = ($name, $($value),+);
+            }
         }
     };
 }
+
+/// Helper macro to format a value
+#[macro_export]
+macro_rules! format_value {
+    ($value:expr) => {{
+        format!("{:?}", $value)
+    }};
+}