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,22 @@
             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,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_debug,
 };
 
 use super::{
@@ -77,9 +77,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_debug!(name: "ManualReader.RegisterPipeline.DuplicateRegistration");
             }
         });
     }

opentelemetry-sdk/src/metrics/meter.rs

@@ -2,12 +2,12 @@
 use std::{borrow::Cow, sync::Arc};
 
 use opentelemetry::{
-    global,
     metrics::{
         AsyncInstrumentBuilder, Counter, Gauge, Histogram, HistogramBuilder, InstrumentBuilder,
         InstrumentProvider, MetricsError, ObservableCounter, ObservableGauge,
         ObservableUpDownCounter, Result, UpDownCounter,
     },
+    otel_error,
 };
 
 use crate::instrumentation::Scope;
@@ -75,14 +75,18 @@
     {
         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.InstrumentCreationFailed", 
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
             return Counter::new(Arc::new(NoopSyncInstrument::new()));
         }
 
         match resolver
             .lookup(
                 InstrumentKind::Counter,
-                builder.name,
+                builder.name.clone(),
                 builder.description,
                 builder.unit,
                 None,
@@ -91,7 +95,12 @@
         {
             Ok(counter) => counter,
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(
+                    name: "SdkMeter.CreateCounter.InstrumentCreationFailed",
+                    meter_name = self.scope.name.as_ref(),
+                    instrument_name = builder.name.as_ref(),
+                    error = format!("Measurements from the instrument will be ignored. Reason:  {}", err)
+                );
                 Counter::new(Arc::new(NoopSyncInstrument::new()))
             }
         }
@@ -107,34 +116,41 @@
     {
         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.InstrumentCreationFailed", 
+                    meter_name = self.scope.name.as_ref(),
+                    instrument_name = builder.name.as_ref(),
+                    error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
             return ObservableCounter::new();
         }
 
         match resolver.measures(
             InstrumentKind::ObservableCounter,
-            builder.name,
+            builder.name.clone(),
             builder.description,
             builder.unit,
             None,
         ) {
             Ok(ms) => {
                 if ms.is_empty() {
+                    otel_error!(
+                        name: "SdkMeter.CreateObservableCounter.InstrumentCreationFailed",
+                        meter_name = self.scope.name.as_ref(),
+                        instrument_name = builder.name.as_ref(),
+                        message = "Measurements from the instrument will be ignored. Reason: View Configuration / Drop Aggregation"
+                    );
                     return ObservableCounter::new();
                 }
-
                 let observable = Arc::new(Observable::new(ms));
-
                 for callback in builder.callbacks {
                     let cb_inst = Arc::clone(&observable);
                     self.pipes
                         .register_callback(move || callback(cb_inst.as_ref()));
                 }
-
                 ObservableCounter::new()
             }
-            Err(err) => {
-                global::handle_error(err);
+            Err(_err) => {
+                // TBD - Add error handling
                 ObservableCounter::new()
             }
         }
@@ -150,34 +166,41 @@
     {
         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.InstrumentCreationFailed", 
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
             return ObservableUpDownCounter::new();
         }
 
         match resolver.measures(
             InstrumentKind::ObservableUpDownCounter,
-            builder.name,
+            builder.name.clone(),
             builder.description,
             builder.unit,
             None,
         ) {
             Ok(ms) => {
                 if ms.is_empty() {
+                    otel_error!(
+                        name: "SdkMeter.CreateUpDownObservableCounter.InstrumentCreationFailed",
+                        meter_name = self.scope.name.as_ref(),
+                        instrument_name = builder.name.as_ref(),
+                        message = "Measurements from the instrument will be ignored. Reason: View Configuration / Drop Aggregation"
+                    );
                     return ObservableUpDownCounter::new();
                 }
-
                 let observable = Arc::new(Observable::new(ms));
-
                 for callback in builder.callbacks {
                     let cb_inst = Arc::clone(&observable);
                     self.pipes
                         .register_callback(move || callback(cb_inst.as_ref()));
                 }
-
                 ObservableUpDownCounter::new()
             }
-            Err(err) => {
-                global::handle_error(err);
+            Err(_err) => {
+                // TBD - Add error handling
                 ObservableUpDownCounter::new()
             }
         }
@@ -193,34 +216,41 @@
     {
         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.InstrumentCreationFailed", 
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+            error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
             return ObservableGauge::new();
         }
 
         match resolver.measures(
             InstrumentKind::ObservableGauge,
-            builder.name,
+            builder.name.clone(),
             builder.description,
             builder.unit,
             None,
         ) {
             Ok(ms) => {
                 if ms.is_empty() {
+                    otel_error!(
+                        name: "SdkMeter.CreateObservableGauge.InstrumentCreationFailed",
+                        meter_name = self.scope.name.as_ref(),
+                        instrument_name = builder.name.as_ref(),
+                        message = "Measurements from the instrument will be ignored. Reason: View Configuration / Drop Aggregation"
+                    );
                     return ObservableGauge::new();
                 }
-
                 let observable = Arc::new(Observable::new(ms));
-
                 for callback in builder.callbacks {
                     let cb_inst = Arc::clone(&observable);
                     self.pipes
                         .register_callback(move || callback(cb_inst.as_ref()));
                 }
-
                 ObservableGauge::new()
             }
-            Err(err) => {
-                global::handle_error(err);
+            Err(_err) => {
+                //TBD - Add error handling
                 ObservableGauge::new()
             }
         }
@@ -236,14 +266,18 @@
     {
         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.InstrumentCreationFailed",
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
             return UpDownCounter::new(Arc::new(NoopSyncInstrument::new()));
         }
 
         match resolver
             .lookup(
                 InstrumentKind::UpDownCounter,
-                builder.name,
+                builder.name.clone(),
                 builder.description,
                 builder.unit,
                 None,
@@ -252,7 +286,12 @@
         {
             Ok(updown_counter) => updown_counter,
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(
+                        name: "SdkMeter.CreateUpDownCounter.InstrumentCreationFailed",
+                        meter_name = self.scope.name.as_ref(),
+                        instrument_name = builder.name.as_ref(),
+                        error = format!("Measurements from the instrument will be ignored. Reason:  {}", err)
+                );
                 UpDownCounter::new(Arc::new(NoopSyncInstrument::new()))
             }
         }
@@ -268,14 +307,18 @@
     {
         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.InstrumentCreationFailed", 
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
             return Gauge::new(Arc::new(NoopSyncInstrument::new()));
         }
 
         match resolver
             .lookup(
                 InstrumentKind::Gauge,
-                builder.name,
+                builder.name.clone(),
                 builder.description,
                 builder.unit,
                 None,
@@ -284,7 +327,12 @@
         {
             Ok(gauge) => gauge,
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(
+                    name: "SdkMeter.CreateGauge.InstrumentCreationFailed",
+                    meter_name = self.scope.name.as_ref(),
+                    instrument_name = builder.name.as_ref(),
+                    error = format!("Measurements from the instrument will be ignored. Reason:  {}", err)
+                );
                 Gauge::new(Arc::new(NoopSyncInstrument::new()))
             }
         }
@@ -300,14 +348,19 @@
     {
         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.InstrumentCreationFailed", 
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                error = format!("Measurements from the instrument will be ignored. Reason: {}", err));
+
             return Histogram::new(Arc::new(NoopSyncInstrument::new()));
         }
 
         match resolver
             .lookup(
                 InstrumentKind::Histogram,
-                builder.name,
+                builder.name.clone(),
                 builder.description,
                 builder.unit,
                 builder.boundaries,
@@ -316,7 +369,12 @@
         {
             Ok(histogram) => histogram,
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(
+                    name: "SdkMeter.CreateHistogram.InstrumentCreationFailed",
+                    meter_name = self.scope.name.as_ref(),
+                    instrument_name = builder.name.as_ref(),
+                    error = format!("Measurements from the instrument will be ignored. Reason:  {}", err)
+                );
                 Histogram::new(Arc::new(NoopSyncInstrument::new()))
             }
         }