Global error handler cleanup - Metrics SDK

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

@@ -16,6 +16,11 @@
     size < STREAM_CARDINALITY_LIMIT as usize
 }
 
+/// Checks whether aggregator has hit cardinality limit for metric streams
+pub(crate) fn cardinality_limit() -> usize {
+    STREAM_CARDINALITY_LIMIT as usize
+}
+
 /// Receives measurements to be aggregated.
 pub(crate) trait Measure<T>: Send + Sync + 'static {
     fn call(&self, measurement: T, attrs: &[KeyValue]);

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

@@ -12,12 +12,12 @@
 use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, AtomicUsize, Ordering};
 use std::sync::{Arc, RwLock};
 
-use aggregate::is_under_cardinality_limit;
+use aggregate::{cardinality_limit, is_under_cardinality_limit};
 pub(crate) use aggregate::{AggregateBuilder, ComputeAggregation, Measure};
 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_warn, KeyValue};
 
 use crate::metrics::AttributeSet;
 
@@ -146,9 +146,10 @@
             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."
+            //TODO -  include name of meter, instrument
+            otel_warn!( name: "MetricCardinalityLimitReached",
+                error = format!("{}", 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())),
+                cardinality_limit = cardinality_limit() as u64,
             );
         }
     }

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 = format!("{}", 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 = format!("{}", 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 = format!("{}", err));
             return Ok(ObservableCounter::new(Arc::new(NoopAsyncInstrument::new())));
         }
 
@@ -119,6 +119,7 @@
         )?;
 
         if ms.is_empty() {
+            otel_error!(name: "SdkMeter.CreateObservableCounter.Error", error = format!("{}", 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 = format!("{}", err));
             return Ok(ObservableUpDownCounter::new(Arc::new(
                 NoopAsyncInstrument::new(),
             )));
@@ -158,6 +159,7 @@
         )?;
 
         if ms.is_empty() {
+            otel_error!(name: "SdkMeter.CreateObservableUpDownCounter.Error", error = format!("{}",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 = format!("{}", err));
             return Ok(ObservableGauge::new(Arc::new(NoopAsyncInstrument::new())));
         }
 
@@ -197,6 +199,7 @@
         )?;
 
         if ms.is_empty() {
+            otel_error!(name: "SdkMeter.CreateObservableGauge.Error",error = format!("{}", 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 = format!("{}",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 = format!("{}", 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 = format!("{}", 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 = format!("{}",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 = format!("{}", 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 = format!("{}",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 = format!("{}",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,18 @@
                 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: "Instrument.DuplicateMetricStreamDefinitions",
+                    name = format!("{}",id.name),
+                    description = format!("{}", id.description),
+                    kind = format!("{:?}", id.kind),
+                    unit = format!("{}",id.unit),
+                    number = format!("{}", id.number),
+                    existing_name = format!("{}", existing.name),
+                    existing_desc = format!("{}", existing.description),
+                    existing_kind = format!("{:?}", existing.kind),
+                    existing_unit = format!("{}", existing.unit),
+                    existing_number = format!("{}", existing.number),
+                );
             }
         }
     }

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 = format!("{}",MetricsError::Config(
+            "no criteria provided, dropping view".to_string())),
+            criteria = format!("{:?}", criteria),
+            mask = format!("{:?}", 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 = format!("{}", MetricsError::Config(
+                "name replacement for wildcard instrument, dropping view".to_string())),
+                criteria = format!("{:?}", criteria),
+                mask = format!("{:?}", mask)
+            );
             return Ok(Box::new(empty_view));
         }
 
@@ -138,10 +142,11 @@
         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 = format!("{}",err),
+                    criteria = format!("{:?}", err_msg_criteria),
+                    mask = format!("{:?}", mask),
+                );
                 return Ok(Box::new(empty_view));
             }
         }