Merge branch 'main' into feature/update-prometheus-to-otel-27

Author: cijothomas

.github/workflows/ci.yml

@@ -8,6 +8,9 @@ on:
     - main
     paths-ignore:
     - '**.md'
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 jobs:
   test:
     strategy:

.github/workflows/semver.yml

@@ -4,7 +4,6 @@ env:
 on:
   pull_request:
     types: [ labeled, synchronize, opened, reopened ]
-
 jobs:
   semver-compliance: # This job uses the latest published crate as baseline for comparison.
     runs-on: ubuntu-latest

examples/self-diagnostics/src/main.rs

@@ -26,7 +26,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // OpenTelemetry uses `tracing` crate for its internal logging. Unless a
     // tracing subscriber is set, the logs will be discarded. In this example,
     // we configure a `tracing` subscriber to:
-    // 1. Print logs of level INFO or higher to stdout.
+    // 1. Print logs of level INFO or higher to stdout using tracing's fmt layer.
     // 2. Filter logs from OpenTelemetry's dependencies (like tonic, hyper,
     // reqwest etc. which are commonly used by the OTLP exporter) to only print
     // ERROR-level logs. This filtering helps reduce repetitive log messages
@@ -35,7 +35,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // https://github.com/open-telemetry/opentelemetry-rust/issues/761 is
     // resolved.
 
-    // Target name used by OpenTelemetry always start with "opentelemetry".
+    // Target names used by all OpenTelemetry official crates always start with "opentelemetry".
     // Hence, one may use "add_directive("opentelemetry=off".parse().unwrap())"
     // to turn off all logs from OpenTelemetry.
 

opentelemetry-sdk/CHANGELOG.md

@@ -18,6 +18,13 @@
         .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)
+
+  - Bug fix: Empty Logger names are retained as-is instead of replacing with
+    "rust.opentelemetry.io/sdk/logger"
+    [#2316](https://github.com/open-telemetry/opentelemetry-rust/pull/2316)
 
 ## 0.27.0
 

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -1,7 +1,7 @@
 use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext};
 use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource};
 use crate::{logs::LogError, logs::LogResult};
-use opentelemetry::{otel_debug, trace::TraceContextExt, Context, InstrumentationScope};
+use opentelemetry::{otel_debug, otel_info, trace::TraceContextExt, Context, InstrumentationScope};
 
 #[cfg(feature = "spec_unstable_logs_enabled")]
 use opentelemetry::logs::Severity;
@@ -44,19 +44,10 @@ pub struct LoggerProvider {
     inner: Arc<LoggerProviderInner>,
 }
 
-/// Default logger name if empty string is provided.
-const DEFAULT_COMPONENT_NAME: &str = "rust.opentelemetry.io/sdk/logger";
-
 impl opentelemetry::logs::LoggerProvider for LoggerProvider {
     type Logger = Logger;
 
     fn logger(&self, name: impl Into<Cow<'static, str>>) -> Self::Logger {
-        let mut name = name.into();
-
-        if name.is_empty() {
-            name = Cow::Borrowed(DEFAULT_COMPONENT_NAME)
-        };
-
         let scope = InstrumentationScope::builder(name).build();
         self.logger_with_scope(scope)
     }
@@ -66,6 +57,9 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider {
         if self.inner.is_shutdown.load(Ordering::Relaxed) {
             return Logger::new(scope, NOOP_LOGGER_PROVIDER.clone());
         }
+        if scope.name().is_empty() {
+            otel_info!(name: "LoggerNameEmpty",  message = "Logger name is empty; consider providing a meaningful name. Logger will function normally and the provided name will be used as-is.");
+        };
         Logger::new(scope, self.clone())
     }
 }
@@ -154,10 +148,15 @@ impl LoggerProviderInner {
 impl Drop for LoggerProviderInner {
     fn drop(&mut self) {
         if !self.is_shutdown.load(Ordering::Relaxed) {
+            otel_info!(
+                name: "LoggerProvider.Drop",
+                message = "Last reference of LoggerProvider dropped, initiating shutdown."
+            );
             let _ = self.shutdown(); // errors are handled within shutdown
         } else {
             otel_debug!(
-                name: "LoggerProvider.Drop.AlreadyShutdown"
+                name: "LoggerProvider.Drop.AlreadyShutdown",
+                message = "LoggerProvider was already shut down; drop will not attempt shutdown again."
             );
         }
     }
@@ -700,6 +699,42 @@ mod tests {
         assert_eq!(*shutdown_called.lock().unwrap(), 1);
     }
 
+    #[test]
+    fn test_empty_logger_name() {
+        let exporter = InMemoryLogExporter::default();
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter.clone())
+            .build();
+        let logger = logger_provider.logger("");
+        let mut record = logger.create_log_record();
+        record.set_body("Testing empty logger name".into());
+        logger.emit(record);
+
+        // Create a logger using a scope with an empty name
+        let scope = InstrumentationScope::builder("").build();
+        let scoped_logger = logger_provider.logger_with_scope(scope);
+        let mut scoped_record = scoped_logger.create_log_record();
+        scoped_record.set_body("Testing empty logger scope name".into());
+        scoped_logger.emit(scoped_record);
+
+        // Assert: Verify that the emitted logs are processed correctly
+        let emitted_logs = exporter.get_emitted_logs().unwrap();
+        assert_eq!(emitted_logs.len(), 2);
+        // Assert the first log
+        assert_eq!(
+            emitted_logs[0].clone().record.body,
+            Some(AnyValue::String("Testing empty logger name".into()))
+        );
+        assert_eq!(logger.instrumentation_scope().name(), "");
+
+        // Assert the second log created through the scope
+        assert_eq!(
+            emitted_logs[1].clone().record.body,
+            Some(AnyValue::String("Testing empty logger scope name".into()))
+        );
+        assert_eq!(scoped_logger.instrumentation_scope().name(), "");
+    }
+
     #[derive(Debug)]
     pub(crate) struct LazyLogProcessor {
         shutdown_called: Arc<Mutex<bool>>,

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -9,7 +9,7 @@ use std::{
 
 use opentelemetry::{
     metrics::{Meter, MeterProvider},
-    otel_debug, otel_error, InstrumentationScope,
+    otel_debug, otel_error, otel_info, InstrumentationScope,
 };
 
 use crate::metrics::{MetricError, MetricResult};
@@ -109,6 +109,10 @@ impl SdkMeterProvider {
     /// There is no guaranteed that all telemetry be flushed or all resources have
     /// been released on error.
     pub fn shutdown(&self) -> MetricResult<()> {
+        otel_info!(
+            name: "MeterProvider.Shutdown",
+            message = "User initiated shutdown of MeterProvider."
+        );
         self.inner.shutdown()
     }
 }
@@ -139,28 +143,31 @@ impl Drop for SdkMeterProviderInner {
         // shutdown(), then we don't need to call shutdown again.
         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."
+                name: "MeterProvider.Drop.AlreadyShutdown",
+                message = "MeterProvider 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)
+        } else {
+            otel_info!(
+                name: "MeterProvider.Drop",
+                message = "Last reference of MeterProvider dropped, initiating shutdown."
             );
+            if let Err(err) = self.shutdown() {
+                otel_error!(
+                    name: "MeterProvider.Drop.ShutdownFailed",
+                    message = "Shutdown attempt failed during drop of MeterProvider.",
+                    reason = format!("{}", err)
+                );
+            } else {
+                otel_info!(
+                    name: "MeterProvider.Drop.ShutdownCompleted",
+                );
+            }
         }
     }
 }
 
-/// 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)
     }
@@ -170,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)
@@ -231,7 +242,7 @@ impl MeterProviderBuilder {
     /// Construct a new [MeterProvider] with this configuration.
 
     pub fn build(self) -> SdkMeterProvider {
-        SdkMeterProvider {
+        let meter_provider = SdkMeterProvider {
             inner: Arc::new(SdkMeterProviderInner {
                 pipes: Arc::new(Pipelines::new(
                     self.resource.unwrap_or_default(),
@@ -241,7 +252,12 @@ impl MeterProviderBuilder {
                 meters: Default::default(),
                 is_shutdown: AtomicBool::new(false),
             }),
-        }
+        };
+
+        otel_info!(
+            name: "MeterProvider.Built",
+        );
+        meter_provider
     }
 }
 

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-sdk/src/metrics/periodic_reader.rs

@@ -234,10 +234,18 @@ impl<RT: Runtime> PeriodicReaderWorker<RT> {
     async fn collect_and_export(&mut self) -> MetricResult<()> {
         self.reader.collect(&mut self.rm)?;
         if self.rm.scope_metrics.is_empty() {
+            otel_debug!(
+                name: "PeriodicReaderWorker.NoMetricsToExport",
+            );
             // No metrics to export.
             return Ok(());
         }
 
+        otel_debug!(
+            name: "PeriodicReaderWorker.InvokeExporter",
+            message = "Calling exporter's export method with collected metrics.",
+            count = self.rm.scope_metrics.len(),
+        );
         let export = self.reader.exporter.export(&mut self.rm);
         let timeout = self.runtime.delay(self.timeout);
         pin_mut!(export);

opentelemetry/Cargo.toml

@@ -21,19 +21,18 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-futures-core = { workspace = true }
-futures-sink = "0.3"
-once_cell = { workspace = true }
+futures-core = { workspace = true, optional = true }
+futures-sink = { version = "0.3", optional = true }
 pin-project-lite = { workspace = true, optional = true }
-thiserror = { workspace = true }
+thiserror = { workspace = true, optional = true}
 tracing = {workspace = true, optional = true} # optional for opentelemetry internal logging
 
 [target.'cfg(all(target_arch = "wasm32", not(target_os = "wasi")))'.dependencies]
 js-sys = "0.3.63"
 
 [features]
-default = ["trace", "metrics", "logs"]
-trace = ["pin-project-lite"]
+default = ["trace", "metrics", "logs", "internal-logs"]
+trace = ["pin-project-lite", "futures-sink", "futures-core", "thiserror"]
 metrics = []
 testing = ["trace", "metrics"]
 logs = []

opentelemetry/src/baggage.rs

@@ -15,16 +15,22 @@
 //!
 //! [W3C Baggage]: https://w3c.github.io/baggage
 use crate::{Context, Key, KeyValue, Value};
-use once_cell::sync::Lazy;
 use std::collections::{hash_map, HashMap};
 use std::fmt;
+use std::sync::OnceLock;
 
-static DEFAULT_BAGGAGE: Lazy<Baggage> = Lazy::new(Baggage::default);
+static DEFAULT_BAGGAGE: OnceLock<Baggage> = OnceLock::new();
 
 const MAX_KEY_VALUE_PAIRS: usize = 180;
 const MAX_BYTES_FOR_ONE_PAIR: usize = 4096;
 const MAX_LEN_OF_ALL_PAIRS: usize = 8192;
 
+/// Returns the default baggage, ensuring it is initialized only once.
+#[inline]
+fn get_default_baggage() -> &'static Baggage {
+    DEFAULT_BAGGAGE.get_or_init(Baggage::default)
+}
+
 /// A set of name/value pairs describing user-defined properties.
 ///
 /// ### Baggage Names
@@ -399,7 +405,7 @@ impl BaggageExt for Context {
     }
 
     fn baggage(&self) -> &Baggage {
-        self.get::<Baggage>().unwrap_or(&DEFAULT_BAGGAGE)
+        self.get::<Baggage>().unwrap_or(get_default_baggage())
     }
 }