Merge branch 'main' into global-error-handler-cleanup-metrics-sdk

Author: lalitb

examples/metrics-advanced/Cargo.toml

@@ -8,6 +8,6 @@ publish = false
 [dependencies]
 opentelemetry = { path = "../../opentelemetry", features = ["metrics"] }
 opentelemetry_sdk = { path = "../../opentelemetry-sdk", features = ["metrics", "rt-tokio"] }
-opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["metrics"]}
+opentelemetry-stdout = { path = "../../opentelemetry-stdout", features = ["metrics"] }
 tokio = { workspace = true, features = ["full"] }
 serde_json = { workspace = true }

examples/metrics-advanced/src/main.rs

@@ -2,7 +2,7 @@ use opentelemetry::global;
 use opentelemetry::Key;
 use opentelemetry::KeyValue;
 use opentelemetry_sdk::metrics::{
-    Aggregation, Instrument, PeriodicReader, SdkMeterProvider, Stream,
+    data::Temporality, Aggregation, Instrument, PeriodicReader, SdkMeterProvider, Stream,
 };
 use opentelemetry_sdk::{runtime, Resource};
 use std::error::Error;
@@ -44,7 +44,11 @@ fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
         }
     };
 
-    let exporter = opentelemetry_stdout::MetricsExporterBuilder::default().build();
+    // Build exporter using Delta Temporality.
+    let exporter = opentelemetry_stdout::MetricsExporterBuilder::default()
+        .with_temporality(Temporality::Delta)
+        .build();
+
     let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
     let provider = SdkMeterProvider::builder()
         .with_reader(reader)

examples/metrics-basic/src/main.rs

@@ -6,7 +6,10 @@ use std::error::Error;
 use std::vec;
 
 fn init_meter_provider() -> opentelemetry_sdk::metrics::SdkMeterProvider {
-    let exporter = opentelemetry_stdout::MetricsExporterBuilder::default().build();
+    let exporter = opentelemetry_stdout::MetricsExporterBuilder::default()
+        // Build exporter using Delta Temporality (Defaults to Temporality::Cumulative)
+        // .with_temporality(data::Temporality::Delta)
+        .build();
     let reader = PeriodicReader::builder(exporter, runtime::Tokio).build();
     let provider = SdkMeterProvider::builder()
         .with_reader(reader)

opentelemetry-appender-log/CHANGELOG.md

@@ -3,6 +3,7 @@
 ## vNext
 
 - Bump MSRV to 1.70 [#2179](https://github.com/open-telemetry/opentelemetry-rust/pull/2179)
+- [2193](https://github.com/open-telemetry/opentelemetry-rust/pull/2193) `opentelemetry-appender-log`: Output experimental code attributes 
 
 ## v0.26.0
 Released 2024-Sep-30

opentelemetry-appender-log/Cargo.toml

@@ -11,17 +11,26 @@ rust-version = "1.70"
 edition = "2021"
 
 [dependencies]
-opentelemetry = { version = "0.26", path = "../opentelemetry", features = ["logs"]}
-log = { workspace = true, features = ["kv", "std"]}
+opentelemetry = { version = "0.26", path = "../opentelemetry", features = [
+  "logs",
+] }
+log = { workspace = true, features = ["kv", "std"] }
 serde = { workspace = true, optional = true, features = ["std"] }
+opentelemetry-semantic-conventions = { path = "../opentelemetry-semantic-conventions", optional = true, features = [
+  "semconv_experimental",
+] }
 
 [features]
 logs_level_enabled = ["opentelemetry/logs_level_enabled"]
 with-serde = ["log/kv_serde", "serde"]
+experimental_metadata_attributes = ["dep:opentelemetry-semantic-conventions"]
 
 [dev-dependencies]
-opentelemetry_sdk = { path = "../opentelemetry-sdk", features = [ "testing", "logs_level_enabled" ] }
-opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"]}
+opentelemetry_sdk = { path = "../opentelemetry-sdk", features = [
+  "testing",
+  "logs_level_enabled",
+] }
+opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"] }
 log = { workspace = true, features = ["kv_serde"] }
 tokio = { workspace = true }
 serde = { workspace = true, features = ["std", "derive"] }

opentelemetry-appender-log/src/lib.rs

@@ -99,6 +99,8 @@ use opentelemetry::{
     logs::{AnyValue, LogRecord, Logger, LoggerProvider, Severity},
     Key,
 };
+#[cfg(feature = "experimental_metadata_attributes")]
+use opentelemetry_semantic_conventions::attribute::{CODE_FILEPATH, CODE_LINENO, CODE_NAMESPACE};
 use std::borrow::Cow;
 
 pub struct OpenTelemetryLogBridge<P, L>
@@ -130,6 +132,28 @@ where
             log_record.set_severity_number(severity_of_level(record.level()));
             log_record.set_severity_text(record.level().as_str());
             log_record.set_body(AnyValue::from(record.args().to_string()));
+
+            #[cfg(feature = "experimental_metadata_attributes")]
+            {
+                if let Some(filepath) = record.file() {
+                    log_record.add_attribute(
+                        Key::new(CODE_FILEPATH),
+                        AnyValue::from(filepath.to_string()),
+                    );
+                }
+
+                if let Some(line_no) = record.line() {
+                    log_record.add_attribute(Key::new(CODE_LINENO), AnyValue::from(line_no));
+                }
+
+                if let Some(module) = record.module_path() {
+                    log_record.add_attribute(
+                        Key::new(CODE_NAMESPACE),
+                        AnyValue::from(module.to_string()),
+                    );
+                }
+            }
+
             log_record.add_attributes(log_attributes(record.key_values()));
             log_record.set_target(record.metadata().target().to_string());
 
@@ -1127,6 +1151,54 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "experimental_metadata_attributes")]
+    #[test]
+    fn logbridge_code_attributes() {
+        use opentelemetry_semantic_conventions::attribute::{
+            CODE_FILEPATH, CODE_LINENO, CODE_NAMESPACE,
+        };
+
+        let exporter = InMemoryLogsExporter::default();
+
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter.clone())
+            .build();
+
+        let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);
+
+        otel_log_appender.log(
+            &log::RecordBuilder::new()
+                .level(log::Level::Warn)
+                .args(format_args!("WARN"))
+                .file(Some("src/main.rs"))
+                .module_path(Some("service"))
+                .line(Some(101))
+                .build(),
+        );
+
+        let logs = exporter.get_emitted_logs().unwrap();
+
+        let get = |needle: &str| -> Option<AnyValue> {
+            logs[0].record.attributes_iter().find_map(|(k, v)| {
+                if k.as_str() == needle {
+                    Some(v.clone())
+                } else {
+                    None
+                }
+            })
+        };
+
+        assert_eq!(
+            Some(AnyValue::String(StringValue::from("src/main.rs"))),
+            get(CODE_FILEPATH)
+        );
+        assert_eq!(
+            Some(AnyValue::String(StringValue::from("service"))),
+            get(CODE_NAMESPACE)
+        );
+        assert_eq!(Some(AnyValue::Int(101)), get(CODE_LINENO));
+    }
+
     #[test]
     fn test_flush() {
         let exporter = InMemoryLogsExporter::default();

opentelemetry-appender-tracing/Cargo.toml

@@ -26,6 +26,7 @@ tracing-subscriber = { workspace = true, features = ["registry", "std", "env-fil
 tracing-log = "0.2"
 async-trait = { workspace = true }
 criterion = { workspace = true }
+tokio = { workspace = true, features = ["full"]}
 
 [target.'cfg(not(target_os = "windows"))'.dev-dependencies]
 pprof = { version = "0.13", features = ["flamegraph", "criterion"] }

opentelemetry-appender-tracing/src/layer.rs

@@ -208,17 +208,20 @@ const fn severity_of_level(level: &Level) -> Severity {
 #[cfg(test)]
 mod tests {
     use crate::layer;
-    use opentelemetry::logs::Severity;
+    use async_trait::async_trait;
+    use opentelemetry::logs::{LogResult, Severity};
     use opentelemetry::trace::TracerProvider as _;
     use opentelemetry::trace::{TraceContextExt, TraceFlags, Tracer};
     use opentelemetry::{logs::AnyValue, Key};
+    use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
     use opentelemetry_sdk::logs::{LogRecord, LoggerProvider};
     use opentelemetry_sdk::testing::logs::InMemoryLogsExporter;
     use opentelemetry_sdk::trace;
     use opentelemetry_sdk::trace::{Sampler, TracerProvider};
-    use tracing::error;
+    use tracing::{error, warn};
     use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
-    use tracing_subscriber::Layer;
+    use tracing_subscriber::util::SubscriberInitExt;
+    use tracing_subscriber::{EnvFilter, Layer};
 
     pub fn attributes_contains(log_record: &LogRecord, key: &Key, value: &AnyValue) -> bool {
         log_record
@@ -238,6 +241,70 @@ mod tests {
     }
 
     // cargo test --features=testing
+
+    #[derive(Clone, Debug, Default)]
+    struct ReentrantLogExporter;
+
+    #[async_trait]
+    impl LogExporter for ReentrantLogExporter {
+        async fn export(&mut self, _batch: LogBatch<'_>) -> LogResult<()> {
+            // This will cause a deadlock as the export itself creates a log
+            // while still within the lock of the SimpleLogProcessor.
+            warn!(name: "my-event-name", target: "reentrant", event_id = 20, user_name = "otel", user_email = "[email protected]");
+            Ok(())
+        }
+    }
+
+    #[test]
+    #[ignore = "See issue: https://github.com/open-telemetry/opentelemetry-rust/issues/1745"]
+    fn simple_processor_deadlock() {
+        let exporter: ReentrantLogExporter = ReentrantLogExporter;
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter.clone())
+            .build();
+
+        let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider);
+
+        // Setting subscriber as global as that is the only way to test this scenario.
+        tracing_subscriber::registry().with(layer).init();
+        warn!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "[email protected]");
+    }
+
+    #[test]
+    #[ignore = "While this test runs fine, this uses global subscriber and does not play well with other tests."]
+    fn simple_processor_no_deadlock() {
+        let exporter: ReentrantLogExporter = ReentrantLogExporter;
+        let logger_provider = LoggerProvider::builder()
+            .with_simple_exporter(exporter.clone())
+            .build();
+
+        let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider);
+
+        // This filter will prevent the deadlock as the reentrant log will be
+        // ignored.
+        let filter = EnvFilter::new("debug").add_directive("reentrant=error".parse().unwrap());
+        // Setting subscriber as global as that is the only way to test this scenario.
+        tracing_subscriber::registry()
+            .with(filter)
+            .with(layer)
+            .init();
+        warn!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "[email protected]");
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    #[ignore = "While this test runs fine, this uses global subscriber and does not play well with other tests."]
+    async fn batch_processor_no_deadlock() {
+        let exporter: ReentrantLogExporter = ReentrantLogExporter;
+        let logger_provider = LoggerProvider::builder()
+            .with_batch_exporter(exporter.clone(), opentelemetry_sdk::runtime::Tokio)
+            .build();
+
+        let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider);
+
+        tracing_subscriber::registry().with(layer).init();
+        warn!(name: "my-event-name", target: "my-system", event_id = 20, user_name = "otel", user_email = "[email protected]");
+    }
+
     #[test]
     fn tracing_appender_standalone() {
         // Arrange

opentelemetry-otlp/CHANGELOG.md

@@ -10,6 +10,16 @@ Released 2024-Sep-30
 - Update `opentelemetry-http` dependency version to 0.26
 - Update `opentelemetry-proto` dependency version to 0.26
 - Bump MSRV to 1.71.1 [2140](https://github.com/open-telemetry/opentelemetry-rust/pull/2140)
+- **BREAKING**: [#2217](https://github.com/open-telemetry/opentelemetry-rust/pull/2217)
+  - **Replaced**: The `MetricsExporterBuilder` interface is modified from `with_temporality_selector` to `with_temporality` example can be seen below:
+    Previous Signature:
+    ```rust
+    MetricsExporterBuilder::default().with_temporality_selector(DeltaTemporalitySelector::new())
+    ```
+    Updated Signature:
+    ```rust
+    MetricsExporterBuilder::default().with_temporality(Temporality::Delta)
+    ```
 
 ## v0.25.0
 

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

@@ -17,8 +17,6 @@ use opentelemetry_proto::transform::trace::tonic::group_spans_by_resource_and_sc
 use opentelemetry_sdk::export::logs::LogBatch;
 #[cfg(feature = "trace")]
 use opentelemetry_sdk::export::trace::SpanData;
-#[cfg(feature = "metrics")]
-use opentelemetry_sdk::metrics::data::ResourceMetrics;
 use prost::Message;
 use std::collections::HashMap;
 use std::env;
@@ -77,9 +75,7 @@ impl Default for HttpConfig {
 ///
 /// ```
 /// # #[cfg(feature="metrics")]
-/// use opentelemetry_sdk::metrics::reader::{
-///     DefaultTemporalitySelector,
-/// };
+/// use opentelemetry_sdk::metrics::data::Temporality;
 ///
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// // Create a span exporter you can use to when configuring tracer providers
@@ -91,7 +87,7 @@ impl Default for HttpConfig {
 /// let metrics_exporter = opentelemetry_otlp::new_exporter()
 ///     .http()
 ///     .build_metrics_exporter(
-///         Box::new(DefaultTemporalitySelector::new()),
+///         Temporality::default(),
 ///     )?;
 ///
 /// // Create a log exporter you can use when configuring logger providers
@@ -251,7 +247,7 @@ impl HttpExporterBuilder {
     #[cfg(feature = "metrics")]
     pub fn build_metrics_exporter(
         mut self,
-        temporality_selector: Box<dyn opentelemetry_sdk::metrics::reader::TemporalitySelector>,
+        temporality: opentelemetry_sdk::metrics::data::Temporality,
     ) -> opentelemetry::metrics::Result<crate::MetricsExporter> {
         use crate::{
             OTEL_EXPORTER_OTLP_METRICS_ENDPOINT, OTEL_EXPORTER_OTLP_METRICS_HEADERS,
@@ -265,7 +261,7 @@ impl HttpExporterBuilder {
             OTEL_EXPORTER_OTLP_METRICS_HEADERS,
         )?;
 
-        Ok(crate::MetricsExporter::new(client, temporality_selector))
+        Ok(crate::MetricsExporter::new(client, temporality))
     }
 }
 
@@ -341,7 +337,7 @@ impl OtlpHttpClient {
     #[cfg(feature = "metrics")]
     fn build_metrics_export_body(
         &self,
-        metrics: &mut ResourceMetrics,
+        metrics: &mut opentelemetry_sdk::metrics::data::ResourceMetrics,
     ) -> opentelemetry::metrics::Result<(Vec<u8>, &'static str)> {
         use opentelemetry_proto::tonic::collector::metrics::v1::ExportMetricsServiceRequest;