Global error handler cleanup - Metrics SDK

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

@@ -16,6 +16,11 @@ pub(crate) fn is_under_cardinality_limit(size: usize) -> bool {
     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,22 @@ impl<T: Number> ExpoHistogramDataPoint<T> {
             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(),
-                ));
+
+                // This error is logged when a measurement is dropped because its value is either too high
+                // or too low, falling outside the allowable range defined by the scale and max_size.
+                // If these values are expected, the user should adjust the histogram configuration
+                // to accommodate the range.
+                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,
+                    value = format!("{:?}", v),
+                    error = format!("The measurement will be dropped due to scale underflow. Check the histogram configuration")
+                );
                 return;
             }
             // Downscale

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

@@ -12,12 +12,11 @@ use std::ops::{Add, AddAssign, Sub};
 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 +145,10 @@ impl<AU: AtomicallyUpdate<T>, T: Number, O: Operation> ValueMap<AU, T, O> {
             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",
+                message = format!("{}", "Maximum data points for metric stream exceeded. Entry added to overflow. Subsequent overflows to same metric will not be logged until next collect."),
+                cardinality_limit = cardinality_limit() as u64,
             );
         }
     }

opentelemetry-sdk/src/metrics/manual_reader.rs

@@ -4,8 +4,8 @@ use std::{
 };
 
 use opentelemetry::{
-    global,
     metrics::{MetricsError, Result},
+    otel_debug,
 };
 
 use super::{
@@ -76,10 +76,11 @@ impl MetricReader for ManualReader {
             // Only register once. If producer is already set, do nothing.
             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(),
-                ))
+            }  else {
+                otel_debug!(
+                    name: "ManualReader.RegisterPipeline.DuplicateRegistration",
+                    error = "The pipeline is already registered to the Reader. Registering pipeline multiple times is not allowed."
+                );
             }
         });
     }