Empty MeterName retained as is instead of using default name (#2334)

Author: cijothomas

opentelemetry-sdk/CHANGELOG.md

@@ -18,6 +18,9 @@
         .build();
     ```
   - `logs::LogData` struct is deprecated, and scheduled to be removed from public API in `v0.28.0`.
+  - Bug fix: Empty Meter names are retained as-is instead of replacing with
+    "rust.opentelemetry.io/sdk/meter"
+    [#2334](https://github.com/open-telemetry/opentelemetry-rust/pull/2334)
 
 ## 0.27.0
 

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -166,15 +166,8 @@ impl Drop for SdkMeterProviderInner {
     }
 }
 
-/// Default meter name if empty string is provided.
-const DEFAULT_COMPONENT_NAME: &str = "rust.opentelemetry.io/sdk/meter";
-
 impl MeterProvider for SdkMeterProvider {
-    fn meter(&self, mut name: &'static str) -> Meter {
-        if name.is_empty() {
-            name = DEFAULT_COMPONENT_NAME
-        };
-
+    fn meter(&self, name: &'static str) -> Meter {
         let scope = InstrumentationScope::builder(name).build();
         self.meter_with_scope(scope)
     }
@@ -184,6 +177,10 @@ impl MeterProvider for SdkMeterProvider {
             return Meter::new(Arc::new(NoopMeter::new()));
         }
 
+        if scope.name().is_empty() {
+            otel_info!(name: "MeterNameEmpty", message = "Meter name is empty; consider providing a meaningful name. Meter will function normally and the provided name will be used as-is.");
+        };
+
         if let Ok(mut meters) = self.inner.meters.lock() {
             let meter = meters
                 .entry(scope)

opentelemetry-sdk/src/metrics/mod.rs

@@ -463,6 +463,44 @@ mod tests {
         }
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn empty_meter_name_retained() {
+        async fn meter_name_retained_helper(
+            meter: Meter,
+            provider: SdkMeterProvider,
+            exporter: InMemoryMetricExporter,
+        ) {
+            // Act
+            let counter = meter.u64_counter("my_counter").build();
+
+            counter.add(10, &[]);
+            provider.force_flush().unwrap();
+
+            // Assert
+            let resource_metrics = exporter
+                .get_finished_metrics()
+                .expect("metrics are expected to be exported.");
+            assert!(
+                resource_metrics[0].scope_metrics[0].metrics.len() == 1,
+                "There should be a single metric"
+            );
+            let meter_name = resource_metrics[0].scope_metrics[0].scope.name();
+            assert_eq!(meter_name, "");
+        }
+
+        let exporter = InMemoryMetricExporter::default();
+        let reader = PeriodicReader::builder(exporter.clone(), runtime::Tokio).build();
+        let meter_provider = SdkMeterProvider::builder().with_reader(reader).build();
+
+        // Test Meter creation in 2 ways, both with empty string as meter name
+        let meter1 = meter_provider.meter("");
+        meter_name_retained_helper(meter1, meter_provider.clone(), exporter.clone()).await;
+
+        let meter_scope = InstrumentationScope::builder("").build();
+        let meter2 = meter_provider.meter_with_scope(meter_scope);
+        meter_name_retained_helper(meter2, meter_provider, exporter).await;
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn counter_duplicate_instrument_merge() {
         // Arrange

opentelemetry/src/global/metrics.rs

@@ -40,8 +40,6 @@ pub fn meter_provider() -> GlobalMeterProvider {
 
 /// Creates a named [`Meter`] via the currently configured global [`MeterProvider`].
 ///
-/// If the name is an empty string, the provider will use a default name.
-///
 /// This is a more convenient way of expressing `global::meter_provider().meter(name)`.
 pub fn meter(name: &'static str) -> Meter {
     meter_provider().meter(name)

opentelemetry/src/metrics/meter.rs

@@ -19,8 +19,6 @@ pub trait MeterProvider {
     /// name needs to be unique so it does not collide with other names used by
     /// an application, nor other applications.
     ///
-    /// If the name is empty, then an implementation defined default name will
-    /// be used instead.
     ///
     /// # Examples
     ///