Merge branch 'main' into cijothomas/metric-export-remove-mut

Author: cijothomas

.github/workflows/ci.yml

@@ -102,7 +102,7 @@ jobs:
         run: |
           cargo install [email protected]
           cd ${{ matrix.example }}
-          cargo check-external-types --config allowed-external-types.toml
+          cargo check-external-types --all-features --config allowed-external-types.toml
   msrv:
     strategy:
       matrix:

opentelemetry-otlp/CHANGELOG.md

@@ -3,6 +3,8 @@
 ## vNext
 
 - Update `tonic` dependency version to 0.13
+- Re-export `tonic` types under `tonic_types`
+  [2898](https://github.com/open-telemetry/opentelemetry-rust/pull/2898)
 
 ## 0.29.0
 

opentelemetry-otlp/allowed-external-types.toml

@@ -3,20 +3,16 @@
 # This is used with cargo-check-external-types to reduce the surface area of downstream crates from
 # the public API. Ideally this can have a few exceptions as possible.
 allowed_external_types = [
-    "opentelemetry::*",
     "opentelemetry_http::*",
     "opentelemetry_sdk::*",
-    # http is a pre 1.0 crate
-    "http::uri::InvalidUri",
-    "http::header::name::InvalidHeaderName",
-    "http::header::value::InvalidHeaderValue",
-    # prost is a pre 1.0 crate
-    "prost::error::EncodeError",
+    # serde
+    "serde::de::Deserialize",
+    "serde::ser::Serialize",
     # tonic is a pre 1.0 crate
-    "tonic::status::Code",
-    "tonic::status::Status",
     "tonic::metadata::map::MetadataMap",
+    "tonic::transport::channel::tls::ClientTlsConfig",
+    "tonic::transport::tls::Certificate",
+    "tonic::transport::tls::Identity",
     "tonic::transport::channel::Channel",
-    "tonic::transport::error::Error",
     "tonic::service::interceptor::Interceptor",
 ]

opentelemetry-otlp/src/lib.rs

@@ -450,3 +450,20 @@ pub enum Protocol {
 #[doc(hidden)]
 /// Placeholder type when no exporter pipeline has been configured in telemetry pipeline.
 pub struct NoExporterConfig(());
+
+/// Re-exported types from the `tonic` crate.
+#[cfg(feature = "grpc-tonic")]
+pub mod tonic_types {
+    /// Re-exported types from `tonic::metadata`.
+    pub mod metadata {
+        #[doc(no_inline)]
+        pub use tonic::metadata::MetadataMap;
+    }
+
+    /// Re-exported types from `tonic::transport`.
+    #[cfg(feature = "tls")]
+    pub mod transport {
+        #[doc(no_inline)]
+        pub use tonic::transport::{Certificate, ClientTlsConfig, Identity};
+    }
+}

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

@@ -27,7 +27,10 @@ where
 
         buckets.total += value;
         buckets.count += 1;
-        buckets.counts[index] += 1;
+        if !buckets.counts.is_empty() {
+            buckets.counts[index] += 1;
+        }
+
         if value < buckets.min {
             buckets.min = value;
         }
@@ -96,7 +99,12 @@ impl<T: Number> Histogram<T> {
             bounds.sort_by(|a, b| a.partial_cmp(b).expect("NaNs filtered out"));
         }
 
-        let buckets_count = bounds.len() + 1;
+        let buckets_count = if bounds.is_empty() {
+            0
+        } else {
+            bounds.len() + 1
+        };
+
         Histogram {
             value_map: ValueMap::new(buckets_count, cardinality_limit),
             init_time: AggregateTimeInitiator::default(),

opentelemetry-sdk/src/metrics/mod.rs

@@ -440,6 +440,14 @@ mod tests {
         histogram_aggregation_with_custom_bounds_helper(Temporality::Cumulative);
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn histogram_aggregation_with_empty_bounds() {
+        // Run this test with stdout enabled to see output.
+        // cargo test histogram_aggregation_with_empty_bounds --features=testing -- --nocapture
+        histogram_aggregation_with_empty_bounds_helper(Temporality::Delta);
+        histogram_aggregation_with_empty_bounds_helper(Temporality::Cumulative);
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn updown_counter_aggregation_cumulative() {
         // Run this test with stdout enabled to see output.
@@ -2161,6 +2169,55 @@ mod tests {
         assert_eq!(vec![1.0, 2.5, 5.5], data_point.bounds);
         assert_eq!(vec![1, 1, 3, 0], data_point.bucket_counts);
     }
+
+    fn histogram_aggregation_with_empty_bounds_helper(temporality: Temporality) {
+        let mut test_context = TestContext::new(temporality);
+        let histogram = test_context
+            .meter()
+            .u64_histogram("test_histogram")
+            .with_boundaries(vec![])
+            .build();
+        histogram.record(1, &[KeyValue::new("key1", "value1")]);
+        histogram.record(2, &[KeyValue::new("key1", "value1")]);
+        histogram.record(3, &[KeyValue::new("key1", "value1")]);
+        histogram.record(4, &[KeyValue::new("key1", "value1")]);
+        histogram.record(5, &[KeyValue::new("key1", "value1")]);
+
+        test_context.flush_metrics();
+
+        // Assert
+        let MetricData::Histogram(histogram_data) =
+            test_context.get_aggregation::<u64>("test_histogram", None)
+        else {
+            unreachable!()
+        };
+        // Expecting 1 time-series.
+        assert_eq!(histogram_data.data_points.len(), 1);
+        if let Temporality::Cumulative = temporality {
+            assert_eq!(
+                histogram_data.temporality,
+                Temporality::Cumulative,
+                "Should produce cumulative"
+            );
+        } else {
+            assert_eq!(
+                histogram_data.temporality,
+                Temporality::Delta,
+                "Should produce delta"
+            );
+        }
+
+        // find and validate key1=value1 datapoint
+        let data_point =
+            find_histogram_datapoint_with_key_value(&histogram_data.data_points, "key1", "value1")
+                .expect("datapoint with key1=value1 expected");
+
+        assert_eq!(data_point.count, 5);
+        assert_eq!(data_point.sum, 15);
+        assert!(data_point.bounds.is_empty());
+        assert!(data_point.bucket_counts.is_empty());
+    }
+
     fn gauge_aggregation_helper(temporality: Temporality) {
         // Arrange
         let mut test_context = TestContext::new(temporality);

opentelemetry-stdout/src/metrics/exporter.rs

@@ -235,19 +235,21 @@ fn print_hist_data_points<T: Debug>(data_points: &[HistogramDataPoint<T>]) {
             println!("\t\t\t\t ->  {}: {}", kv.key, kv.value.as_str());
         }
 
-        println!("\t\t\tBuckets");
-        let mut lower_bound = f64::NEG_INFINITY;
-        for (i, &upper_bound) in data_point.bounds.iter().enumerate() {
-            let count = data_point.bucket_counts.get(i).unwrap_or(&0);
-            println!("\t\t\t\t {} to {} : {}", lower_bound, upper_bound, count);
-            lower_bound = upper_bound;
-        }
+        if !data_point.bucket_counts.is_empty() {
+            println!("\t\t\tBuckets");
+            let mut lower_bound = f64::NEG_INFINITY;
+            for (i, &upper_bound) in data_point.bounds.iter().enumerate() {
+                let count = data_point.bucket_counts.get(i).unwrap_or(&0);
+                println!("\t\t\t\t {} to {} : {}", lower_bound, upper_bound, count);
+                lower_bound = upper_bound;
+            }
 
-        let last_count = data_point
-            .bucket_counts
-            .get(data_point.bounds.len())
-            .unwrap_or(&0);
-        println!("\t\t\t\t{} to +Infinity : {}", lower_bound, last_count);
+            let last_count = data_point
+                .bucket_counts
+                .get(data_point.bounds.len())
+                .unwrap_or(&0);
+            println!("\t\t\t\t{} to +Infinity : {}", lower_bound, last_count);
+        }
     }
 }