Merge branch 'main' into noop-metrics-benchmark

Author: lalitb

opentelemetry-otlp/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## vNext
 
+### Fixed
+
+- URL encoded values in `OTEL_EXPORTER_OTLP_HEADERS` are now correctly decoded. [#1578](https://github.com/open-telemetry/opentelemetry-rust/pull/1578)
+
 ### Added
 
 - Added `DeltaTemporalitySelector` ([#1568])

opentelemetry-otlp/src/exporter/http/mod.rs

@@ -120,7 +120,11 @@ impl HttpExporterBuilder {
     pub fn with_headers(mut self, headers: HashMap<String, String>) -> Self {
         // headers will be wrapped, so we must do some logic to unwrap first.
         let mut inst_headers = self.http_config.headers.unwrap_or_default();
-        inst_headers.extend(headers);
+        inst_headers.extend(
+            headers
+                .into_iter()
+                .map(|(key, value)| (key, super::url_decode(&value).unwrap_or(value))),
+        );
         self.http_config.headers = Some(inst_headers);
         self
     }
@@ -310,7 +314,7 @@ fn add_header_from_string(input: &str, headers: &mut HashMap<HeaderName, HeaderV
     headers.extend(parse_header_string(input).filter_map(|(key, value)| {
         Some((
             HeaderName::from_str(key).ok()?,
-            HeaderValue::from_str(value).ok()?,
+            HeaderValue::from_str(&value).ok()?,
         ))
     }));
 }

opentelemetry-otlp/src/exporter/mod.rs

@@ -211,18 +211,53 @@ impl<B: HasExportConfig> WithExportConfig for B {
 }
 
 #[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
-fn parse_header_string(value: &str) -> impl Iterator<Item = (&str, &str)> {
+fn url_decode(value: &str) -> Option<String> {
+    let mut result = String::with_capacity(value.len());
+    let mut chars_to_decode = Vec::<u8>::new();
+    let mut all_chars = value.chars();
+
+    loop {
+        let ch = all_chars.next();
+
+        if ch.is_some() && ch.unwrap() == '%' {
+            chars_to_decode.push(
+                u8::from_str_radix(&format!("{}{}", all_chars.next()?, all_chars.next()?), 16)
+                    .ok()?,
+            );
+            continue;
+        }
+
+        if !chars_to_decode.is_empty() {
+            result.push_str(std::str::from_utf8(&chars_to_decode).ok()?);
+            chars_to_decode.clear();
+        }
+
+        if let Some(c) = ch {
+            result.push(c);
+        } else {
+            return Some(result);
+        }
+    }
+}
+
+#[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
+fn parse_header_string(value: &str) -> impl Iterator<Item = (&str, String)> {
     value
         .split_terminator(',')
         .map(str::trim)
         .filter_map(parse_header_key_value_string)
 }
 
 #[cfg(any(feature = "grpc-tonic", feature = "http-proto"))]
-fn parse_header_key_value_string(key_value_string: &str) -> Option<(&str, &str)> {
+fn parse_header_key_value_string(key_value_string: &str) -> Option<(&str, String)> {
     key_value_string
         .split_once('=')
-        .map(|(key, value)| (key.trim(), value.trim()))
+        .map(|(key, value)| {
+            (
+                key.trim(),
+                url_decode(value.trim()).unwrap_or(value.to_string()),
+            )
+        })
         .filter(|(key, value)| !key.is_empty() && !value.is_empty())
 }
 
@@ -267,6 +302,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_url_decode() {
+        let test_cases = vec![
+            // Format: (encoded, expected_decoded)
+            ("v%201", Some("v 1")),
+            ("v 1", Some("v 1")),
+            ("%C3%B6%C3%A0%C2%A7%C3%96abcd%C3%84", Some("öà§ÖabcdÄ")),
+            ("v%XX1", None),
+        ];
+
+        for (encoded, expected_decoded) in test_cases {
+            assert_eq!(
+                super::url_decode(encoded),
+                expected_decoded.map(|v| v.to_string()),
+            )
+        }
+    }
+
     #[test]
     fn test_parse_header_string() {
         let test_cases = vec![
@@ -280,7 +333,10 @@ mod tests {
         for (input_str, expected_headers) in test_cases {
             assert_eq!(
                 super::parse_header_string(input_str).collect::<Vec<_>>(),
-                expected_headers,
+                expected_headers
+                    .into_iter()
+                    .map(|(k, v)| (k, v.to_string()))
+                    .collect::<Vec<_>>(),
             )
         }
     }
@@ -290,6 +346,15 @@ mod tests {
         let test_cases = vec![
             // Format: (input_str, expected_header)
             ("k1=v1", Some(("k1", "v1"))),
+            (
+                "Authentication=Basic AAA",
+                Some(("Authentication", "Basic AAA")),
+            ),
+            (
+                "Authentication=Basic%20AAA",
+                Some(("Authentication", "Basic AAA")),
+            ),
+            ("k1=%XX", Some(("k1", "%XX"))),
             ("", None),
             ("=v1", None),
             ("k1=", None),
@@ -298,7 +363,7 @@ mod tests {
         for (input_str, expected_headers) in test_cases {
             assert_eq!(
                 super::parse_header_key_value_string(input_str),
-                expected_headers,
+                expected_headers.map(|(k, v)| (k, v.to_string())),
             )
         }
     }

opentelemetry-otlp/src/exporter/tonic/mod.rs

@@ -381,7 +381,7 @@ fn parse_headers_from_env(signal_headers_var: &str) -> HeaderMap {
                 .filter_map(|(key, value)| {
                     Some((
                         HeaderName::from_str(key).ok()?,
-                        HeaderValue::from_str(value).ok()?,
+                        HeaderValue::from_str(&value).ok()?,
                     ))
                 })
                 .collect::<HeaderMap>()

opentelemetry-sdk/src/metrics/mod.rs

@@ -590,6 +590,115 @@ mod tests {
         );
     }
 
+    // "multi_thread" tokio flavor must be used else flush won't
+    // be able to make progress!
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    #[ignore = "Known bug: https://github.com/open-telemetry/opentelemetry-rust/issues/1598"]
+    async fn delta_memory_efficiency_test() {
+        // Run this test with stdout enabled to see output.
+        // cargo test delta_memory_efficiency_test --features=metrics,testing -- --nocapture
+
+        // Arrange
+        let exporter = InMemoryMetricsExporterBuilder::new()
+            .with_temporality_selector(DeltaTemporalitySelector())
+            .build();
+        let reader = PeriodicReader::builder(exporter.clone(), runtime::Tokio).build();
+        let meter_provider = SdkMeterProvider::builder().with_reader(reader).build();
+
+        // Act
+        let meter = meter_provider.meter("test");
+        let counter = meter
+            .u64_counter("my_counter")
+            .with_unit(Unit::new("my_unit"))
+            .init();
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+
+        counter.add(1, &[KeyValue::new("key1", "value2")]);
+        counter.add(1, &[KeyValue::new("key1", "value2")]);
+        counter.add(1, &[KeyValue::new("key1", "value2")]);
+
+        meter_provider.force_flush().unwrap();
+
+        // Assert
+        let resource_metrics = exporter
+            .get_finished_metrics()
+            .expect("metrics are expected to be exported.");
+        assert!(!resource_metrics.is_empty());
+        let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
+        assert_eq!(metric.name, "my_counter");
+        assert_eq!(metric.unit.as_str(), "my_unit");
+        let sum = metric
+            .data
+            .as_any()
+            .downcast_ref::<data::Sum<u64>>()
+            .expect("Sum aggregation expected for Counter instruments by default");
+
+        // Expecting 2 time-series.
+        assert_eq!(sum.data_points.len(), 2);
+        assert!(sum.is_monotonic, "Counter should produce monotonic.");
+        assert_eq!(
+            sum.temporality,
+            data::Temporality::Delta,
+            "Should produce Delta as configured"
+        );
+
+        // find and validate key1=value1 datapoint
+        let mut data_point1 = None;
+        for datapoint in &sum.data_points {
+            if datapoint
+                .attributes
+                .iter()
+                .any(|(k, v)| k.as_str() == "key1" && v.as_str() == "value1")
+            {
+                data_point1 = Some(datapoint);
+            }
+        }
+        assert_eq!(
+            data_point1
+                .expect("datapoint with key1=value1 expected")
+                .value,
+            5
+        );
+
+        // find and validate key1=value2 datapoint
+        let mut data_point1 = None;
+        for datapoint in &sum.data_points {
+            if datapoint
+                .attributes
+                .iter()
+                .any(|(k, v)| k.as_str() == "key1" && v.as_str() == "value2")
+            {
+                data_point1 = Some(datapoint);
+            }
+        }
+        assert_eq!(
+            data_point1
+                .expect("datapoint with key1=value2 expected")
+                .value,
+            3
+        );
+
+        // flush again, and validate that nothing is flushed
+        // as delta temporality.
+        meter_provider.force_flush().unwrap();
+        let resource_metrics = exporter
+            .get_finished_metrics()
+            .expect("metrics are expected to be exported.");
+        println!("resource_metrics: {:?}", resource_metrics);
+        assert!(resource_metrics.is_empty(), "No metrics should be exported as no new measurements were recorded since last collect.");
+    }
+
+    struct DeltaTemporalitySelector();
+    impl TemporalitySelector for DeltaTemporalitySelector {
+        fn temporality(&self, _kind: InstrumentKind) -> Temporality {
+            Temporality::Delta
+        }
+    }
+
     struct TestContext {
         exporter: InMemoryMetricsExporter,
         meter_provider: SdkMeterProvider,

opentelemetry-semantic-conventions/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## vNext
 
+### Changed
+
+- Update to [v1.24.0](https://github.com/open-telemetry/semantic-conventions/releases/tag/v1.24.0) of the semantic conventions.
+  [#1596](https://github.com/open-telemetry/opentelemetry-rust/pull/1596)
+
 ## v0.14.0
 
 ### Changed

opentelemetry-semantic-conventions/scripts/generate-consts-from-spec.sh

@@ -5,8 +5,8 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 CRATE_DIR="${SCRIPT_DIR}/../"
 
 # freeze the spec version and generator version to make generation reproducible
-SPEC_VERSION=1.21.0
-SEMCOVGEN_VERSION=0.19.0
+SPEC_VERSION=1.24.0
+SEMCOVGEN_VERSION=0.23.0
 
 cd "$CRATE_DIR"
 

opentelemetry-semantic-conventions/src/lib.rs

@@ -20,4 +20,4 @@ pub mod trace;
 
 /// The schema URL that matches the version of the semantic conventions that
 /// this crate defines.
-pub const SCHEMA_URL: &str = "https://opentelemetry.io/schemas/1.21.0";
+pub const SCHEMA_URL: &str = "https://opentelemetry.io/schemas/1.24.0";