initial commit

README.md

@@ -24,15 +24,19 @@ observability tools.
 
 ## Project Status
 
+The table below summarizes the overall status of each component. Some components
+include unstable features, which are documented in their respective crate
+documentation.
+
 | Signal/Component      | Overall Status     |
 | --------------------  | ------------------ |
 | Logs-API              | RC*                |
 | Logs-SDK              | Beta               |
 | Logs-OTLP Exporter    | Beta               |
 | Logs-Appender-Tracing | Beta               |
 | Metrics-API           | RC                 |
-| Metrics-SDK           | Beta              |
-| Metrics-OTLP Exporter | Beta              |
+| Metrics-SDK           | Beta               |
+| Metrics-OTLP Exporter | Beta               |
 | Traces-API            | Beta               |
 | Traces-SDK            | Beta               |
 | Traces-OTLP Exporter  | Beta               |

examples/self-diagnostics/src/main.rs

@@ -1,6 +1,7 @@
 use opentelemetry::global;
 use opentelemetry::KeyValue;
 use opentelemetry_sdk::metrics::PeriodicReader;
+use opentelemetry_sdk::Resource;
 use std::error::Error;
 use tracing::info;
 use tracing_subscriber::fmt;
@@ -13,6 +14,10 @@ fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
     let reader = PeriodicReader::builder(exporter, opentelemetry_sdk::runtime::Tokio).build();
 
     let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()
+        .with_resource(Resource::new([KeyValue::new(
+            "service.name",
+            "self-diagnostics-example",
+        )]))
         .with_reader(reader)
         .build();
 
@@ -26,7 +31,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 using tracing's fmt layer.
+    // 1. Print logs of level DEBUG 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
@@ -39,7 +44,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // Hence, one may use "add_directive("opentelemetry=off".parse().unwrap())"
     // to turn off all logs from OpenTelemetry.
 
-    let filter = EnvFilter::new("info")
+    let filter = EnvFilter::new("debug")
         .add_directive("hyper=error".parse().unwrap())
         .add_directive("tonic=error".parse().unwrap())
         .add_directive("h2=error".parse().unwrap())
@@ -54,11 +59,14 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     info!("Starting self-diagnostics example");
 
     let meter = global::meter("example");
-    // Create a counter using an invalid name to trigger
-    // internal log about the same.
-    let counter = meter.u64_counter("my_counter with_space").build();
+    let counter = meter.u64_counter("my_counter").build();
     counter.add(10, &[KeyValue::new("key", "value")]);
 
+    let _observable_counter = meter
+        .u64_observable_counter("my_observable_counter")
+        .with_callback(|observer| observer.observe(10, &[KeyValue::new("key", "value")]))
+        .build();
+
     meter_provider.shutdown()?;
     info!("Shutdown complete. Bye!");
     Ok(())

opentelemetry-sdk/CHANGELOG.md

@@ -25,6 +25,12 @@
   - 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)
+
+  - `Logger::provider`: This method is deprecated as of version `0.27.1`. To be removed in `0.28.0`.
+  - `Logger::instrumentation_scope`: This method is deprecated as of version `0.27.1`. To be removed in `0.28.0`
+     Migration Guidance: 
+        - These methods are intended for log appenders. Keep the clone of the provider handle, instead of depending on above methods.
+
 
 ## 0.27.0
 

opentelemetry-sdk/Cargo.toml

@@ -17,7 +17,6 @@ async-trait = { workspace = true, optional = true }
 futures-channel = "0.3"
 futures-executor = { workspace = true }
 futures-util = { workspace = true, features = ["std", "sink", "async-await-macro"] }
-once_cell = { workspace = true }
 percent-encoding = { version = "2.0", optional = true }
 rand = { workspace = true, features = ["std", "std_rng","small_rng"], optional = true }
 glob = { version = "0.3.1", optional =true}

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -11,20 +11,24 @@ use std::{
     borrow::Cow,
     sync::{
         atomic::{AtomicBool, Ordering},
-        Arc,
+        Arc, OnceLock,
     },
 };
 
-use once_cell::sync::Lazy;
-
 // a no nop logger provider used as placeholder when the provider is shutdown
-static NOOP_LOGGER_PROVIDER: Lazy<LoggerProvider> = Lazy::new(|| LoggerProvider {
-    inner: Arc::new(LoggerProviderInner {
-        processors: Vec::new(),
-        resource: Resource::empty(),
-        is_shutdown: AtomicBool::new(true),
-    }),
-});
+// TODO - replace it with LazyLock once it is stable
+static NOOP_LOGGER_PROVIDER: OnceLock<LoggerProvider> = OnceLock::new();
+
+#[inline]
+fn noop_logger_provider() -> &'static LoggerProvider {
+    NOOP_LOGGER_PROVIDER.get_or_init(|| LoggerProvider {
+        inner: Arc::new(LoggerProviderInner {
+            processors: Vec::new(),
+            resource: Resource::empty(),
+            is_shutdown: AtomicBool::new(true),
+        }),
+    })
+}
 
 #[derive(Debug, Clone)]
 /// Handles the creation and coordination of [`Logger`]s.
@@ -55,7 +59,7 @@ impl opentelemetry::logs::LoggerProvider for LoggerProvider {
     fn logger_with_scope(&self, scope: InstrumentationScope) -> Self::Logger {
         // If the provider is shutdown, new logger will refer a no-op logger provider.
         if self.inner.is_shutdown.load(Ordering::Relaxed) {
-            return Logger::new(scope, NOOP_LOGGER_PROVIDER.clone());
+            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.");
@@ -238,11 +242,19 @@ impl Logger {
         Logger { scope, provider }
     }
 
+    #[deprecated(
+        since = "0.27.1",
+        note = "This method was intended for appender developers, but has no defined use-case in typical workflows. It is deprecated and will be removed in the next major release."
+    )]
     /// LoggerProvider associated with this logger.
     pub fn provider(&self) -> &LoggerProvider {
         &self.provider
     }
 
+    #[deprecated(
+        since = "0.27.1",
+        note = "This method was intended for appender developers, but has no defined use-case in typical workflows. It is deprecated and will be removed in the next major release."
+    )]
     /// Instrumentation scope of this logger.
     pub fn instrumentation_scope(&self) -> &InstrumentationScope {
         &self.scope
@@ -258,7 +270,7 @@ impl opentelemetry::logs::Logger for Logger {
 
     /// Emit a `LogRecord`.
     fn emit(&self, mut record: Self::LogRecord) {
-        let provider = self.provider();
+        let provider = &self.provider;
         let processors = provider.log_processors();
 
         //let mut log_record = record;
@@ -277,22 +289,17 @@ impl opentelemetry::logs::Logger for Logger {
         }
 
         for p in processors {
-            p.emit(&mut record, self.instrumentation_scope());
+            p.emit(&mut record, &self.scope);
         }
     }
 
     #[cfg(feature = "spec_unstable_logs_enabled")]
     fn event_enabled(&self, level: Severity, target: &str) -> bool {
-        let provider = self.provider();
+        let provider = &self.provider;
 
         let mut enabled = false;
         for processor in provider.log_processors() {
-            enabled = enabled
-                || processor.event_enabled(
-                    level,
-                    target,
-                    self.instrumentation_scope().name().as_ref(),
-                );
+            enabled = enabled || processor.event_enabled(level, target, self.scope.name().as_ref());
         }
         enabled
     }
@@ -725,14 +732,14 @@ mod tests {
             emitted_logs[0].clone().record.body,
             Some(AnyValue::String("Testing empty logger name".into()))
         );
-        assert_eq!(logger.instrumentation_scope().name(), "");
+        assert_eq!(logger.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(), "");
+        assert_eq!(scoped_logger.scope.name(), "");
     }
 
     #[derive(Debug)]

opentelemetry-sdk/src/logs/mod.rs

@@ -108,6 +108,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn logger_attributes() {
         let provider = LoggerProvider::builder().build();
         let scope = InstrumentationScope::builder("test_logger")

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

@@ -12,11 +12,11 @@ use super::{
     precomputed_sum::PrecomputedSum, sum::Sum, Number,
 };
 
-const STREAM_CARDINALITY_LIMIT: u32 = 2000;
+pub(crate) const STREAM_CARDINALITY_LIMIT: usize = 2000;
 
 /// Checks whether aggregator has hit cardinality limit for metric streams
 pub(crate) fn is_under_cardinality_limit(size: usize) -> bool {
-    size < STREAM_CARDINALITY_LIMIT as usize
+    size < STREAM_CARDINALITY_LIMIT
 }
 
 /// Receives measurements to be aggregated.

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

@@ -1,7 +1,7 @@
 use std::{f64::consts::LOG2_E, mem::replace, ops::DerefMut, sync::Mutex, time::SystemTime};
 
-use once_cell::sync::Lazy;
 use opentelemetry::{otel_debug, KeyValue};
+use std::sync::OnceLock;
 
 use crate::metrics::{
     data::{self, Aggregation},
@@ -131,7 +131,7 @@ impl<T: Number> ExpoHistogramDataPoint<T> {
             }
             return (exp - correction) >> -self.scale;
         }
-        (exp << self.scale) + (frac.ln() * SCALE_FACTORS[self.scale as usize]) as i32 - 1
+        (exp << self.scale) + (frac.ln() * scale_factors()[self.scale as usize]) as i32 - 1
     }
 }
 
@@ -165,32 +165,38 @@ fn scale_change(max_size: i32, bin: i32, start_bin: i32, length: i32) -> u32 {
     count
 }
 
-/// Constants used in calculating the logarithm index.
-static SCALE_FACTORS: Lazy<[f64; 21]> = Lazy::new(|| {
-    [
-        LOG2_E * 2f64.powi(0),
-        LOG2_E * 2f64.powi(1),
-        LOG2_E * 2f64.powi(2),
-        LOG2_E * 2f64.powi(3),
-        LOG2_E * 2f64.powi(4),
-        LOG2_E * 2f64.powi(5),
-        LOG2_E * 2f64.powi(6),
-        LOG2_E * 2f64.powi(7),
-        LOG2_E * 2f64.powi(8),
-        LOG2_E * 2f64.powi(9),
-        LOG2_E * 2f64.powi(10),
-        LOG2_E * 2f64.powi(11),
-        LOG2_E * 2f64.powi(12),
-        LOG2_E * 2f64.powi(13),
-        LOG2_E * 2f64.powi(14),
-        LOG2_E * 2f64.powi(15),
-        LOG2_E * 2f64.powi(16),
-        LOG2_E * 2f64.powi(17),
-        LOG2_E * 2f64.powi(18),
-        LOG2_E * 2f64.powi(19),
-        LOG2_E * 2f64.powi(20),
-    ]
-});
+// TODO - replace it with LazyLock once it is stable
+static SCALE_FACTORS: OnceLock<[f64; 21]> = OnceLock::new();
+
+/// returns constants used in calculating the logarithm index.
+#[inline]
+fn scale_factors() -> &'static [f64; 21] {
+    SCALE_FACTORS.get_or_init(|| {
+        [
+            LOG2_E * 2f64.powi(0),
+            LOG2_E * 2f64.powi(1),
+            LOG2_E * 2f64.powi(2),
+            LOG2_E * 2f64.powi(3),
+            LOG2_E * 2f64.powi(4),
+            LOG2_E * 2f64.powi(5),
+            LOG2_E * 2f64.powi(6),
+            LOG2_E * 2f64.powi(7),
+            LOG2_E * 2f64.powi(8),
+            LOG2_E * 2f64.powi(9),
+            LOG2_E * 2f64.powi(10),
+            LOG2_E * 2f64.powi(11),
+            LOG2_E * 2f64.powi(12),
+            LOG2_E * 2f64.powi(13),
+            LOG2_E * 2f64.powi(14),
+            LOG2_E * 2f64.powi(15),
+            LOG2_E * 2f64.powi(16),
+            LOG2_E * 2f64.powi(17),
+            LOG2_E * 2f64.powi(18),
+            LOG2_E * 2f64.powi(19),
+            LOG2_E * 2f64.powi(20),
+        ]
+    })
+}
 
 /// Breaks the number into a normalized fraction and a base-2 exponent.
 ///