Merge branch 'main' into provider-builder-pattern

Author: lalitb

Cargo.toml

@@ -30,7 +30,7 @@ hyper-util = "0.1"
 log = "0.4.21"
 once_cell = "1.13"
 ordered-float = "4.0"
-pin-project-lite = "0.2"
+pin-project-lite = "=0.2.14" # 0.2.15 is failing for cargo-check-external-types
 prost = "0.13"
 prost-build = "0.13"
 prost-types = "0.13"

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_debug, KeyValue};
 
 use crate::{
     metrics::data::{self, Aggregation, Temporality},
@@ -100,9 +100,18 @@ 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(),
-                ));
+
+                // TODO - to check if this should be logged as an error if this is auto-recoverable.
+                otel_debug!(
+                    name: "ExponentialHistogramDataPoint.Scale.Underflow",
+                    current_scale = self.scale,
+                    scale_delta = scale_delta,
+                    max_size = self.max_size,
+                    min_scale = EXPO_MIN_SCALE,
+                    value = format!("{:?}", v),
+                    message = "The measurement will be dropped due to scale underflow. Check the histogram configuration"
+                );
+
                 return;
             }
             // Downscale

opentelemetry-sdk/src/metrics/manual_reader.rs

@@ -4,8 +4,8 @@ use std::{
 };
 
 use opentelemetry::{
-    global,
     metrics::{MetricsError, Result},
+    otel_debug,
 };
 
 use super::{
@@ -77,9 +77,9 @@ impl MetricReader for ManualReader {
             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.DuplicateRegistration",
+                    message = "The pipeline is already registered to the Reader. Registering pipeline multiple times is not allowed.");
             }
         });
     }

opentelemetry-sdk/src/metrics/meter.rs

@@ -8,7 +8,7 @@ use opentelemetry::{
         InstrumentProvider, MetricsError, ObservableCounter, ObservableGauge,
         ObservableUpDownCounter, Result, UpDownCounter,
     },
-    InstrumentationScope,
+    otel_error, InstrumentationScope,
 };
 
 use crate::metrics::{
@@ -75,14 +75,20 @@ impl SdkMeter {
     {
         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: "InstrumentCreationFailed",
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                message = "Measurements from this counter will be ignored.",
+                reason = format!("{}", 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 +97,13 @@ impl SdkMeter {
         {
             Ok(counter) => counter,
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(
+                    name: "InstrumentCreationFailed",
+                    meter_name = self.scope.name.as_ref(),
+                    instrument_name = builder.name.as_ref(),
+                    message = "Measurements from this counter will be ignored.",
+                    reason = format!("{}", err)
+                );
                 Counter::new(Arc::new(NoopSyncInstrument::new()))
             }
         }
@@ -107,19 +119,30 @@ impl SdkMeter {
     {
         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: "InstrumentCreationFailed", 
+                meter_name = self.scope.name.as_ref(),
+                instrument_name = builder.name.as_ref(),
+                message = "Callbacks for this observable counter will not be invoked.",
+                reason = format!("{}", 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: "InstrumentCreationFailed",
+                        meter_name = self.scope.name.as_ref(),
+                        instrument_name = builder.name.as_ref(),
+                        message = "Callbacks for this observable counter will not be invoked. Check View Configuration."
+                    );
                     return ObservableCounter::new();
                 }
 
@@ -134,7 +157,12 @@ impl SdkMeter {
                 ObservableCounter::new()
             }
             Err(err) => {
-                global::handle_error(err);
+                otel_error!(
+                    name: "InstrumentCreationFailed",
+                    meter_name = self.scope.name.as_ref(),
+                    instrument_name = builder.name.as_ref(),
+                    message = "Callbacks for this observable counter will not be invoked.",
+                    reason = format!("{}", err));
                 ObservableCounter::new()
             }
         }

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -8,9 +8,9 @@ use std::{
 };
 
 use opentelemetry::{
-    global,
     metrics::{Meter, MeterProvider, MetricsError, Result},
-    InstrumentationScope,
+    otel_debug, otel_error,
+    InstrumentationScope, KeyValue,
 };
 
 use crate::Resource;
@@ -137,10 +137,17 @@ impl Drop for SdkMeterProviderInner {
     fn drop(&mut self) {
         // If user has already shutdown the provider manually by calling
         // 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);
-            }
+        if self.is_shutdown.load(Ordering::Relaxed) {
+            otel_debug!(
+                name: "MeterProvider.AlreadyShutdown",
+                message = "Meter provider was already shut down; drop will not attempt shutdown again."
+            );
+        } else if let Err(err) = self.shutdown() {
+            otel_error!(
+                name: "MeterProvider.ShutdownFailed",
+                message = "Shutdown attempt failed during drop of MeterProvider.",
+                reason = format!("{}", err)
+            );
         }
     }
 }