Merge branch 'main' into log-record-access

Author: lalitb

opentelemetry-appender-log/src/lib.rs

@@ -769,7 +769,7 @@ mod tests {
     use super::OpenTelemetryLogBridge;
 
     use opentelemetry::{logs::AnyValue, StringValue};
-    use opentelemetry_sdk::{logs::LoggerProvider, testing::logs::InMemoryLogExporter};
+    use opentelemetry_sdk::{logs::InMemoryLogExporter, logs::LoggerProvider};
 
     use log::Log;
 

opentelemetry-appender-tracing/src/layer.rs

@@ -213,9 +213,9 @@ mod tests {
     use opentelemetry::trace::TracerProvider as _;
     use opentelemetry::trace::{TraceContextExt, TraceFlags, Tracer};
     use opentelemetry::{logs::AnyValue, Key};
+    use opentelemetry_sdk::logs::InMemoryLogExporter;
     use opentelemetry_sdk::logs::{LogBatch, LogExporter};
     use opentelemetry_sdk::logs::{LogRecord, LogResult, LoggerProvider};
-    use opentelemetry_sdk::testing::logs::InMemoryLogExporter;
     use opentelemetry_sdk::trace::{Sampler, TracerProvider};
     use tracing::{error, warn};
     use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;

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

@@ -13,10 +13,10 @@ use opentelemetry_proto::transform::common::tonic::ResourceAttributesWithSchema;
 use opentelemetry_proto::transform::logs::tonic::group_logs_by_resource_and_scope;
 #[cfg(feature = "trace")]
 use opentelemetry_proto::transform::trace::tonic::group_spans_by_resource_and_scope;
-#[cfg(feature = "trace")]
-use opentelemetry_sdk::export::trace::SpanData;
 #[cfg(feature = "logs")]
 use opentelemetry_sdk::logs::LogBatch;
+#[cfg(feature = "trace")]
+use opentelemetry_sdk::trace::SpanData;
 use prost::Message;
 use std::collections::HashMap;
 use std::env;

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

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use futures_core::future::BoxFuture;
 use http::{header::CONTENT_TYPE, Method};
 use opentelemetry::{otel_debug, trace::TraceError};
-use opentelemetry_sdk::export::trace::{ExportResult, SpanData, SpanExporter};
+use opentelemetry_sdk::trace::{ExportResult, SpanData, SpanExporter};
 
 use super::OtlpHttpClient;
 

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

@@ -5,7 +5,7 @@ use opentelemetry::{otel_debug, trace::TraceError};
 use opentelemetry_proto::tonic::collector::trace::v1::{
     trace_service_client::TraceServiceClient, ExportTraceServiceRequest,
 };
-use opentelemetry_sdk::export::trace::{ExportResult, SpanData, SpanExporter};
+use opentelemetry_sdk::trace::{ExportResult, SpanData, SpanExporter};
 use tonic::{codegen::CompressionEncoding, service::Interceptor, transport::Channel, Request};
 
 use opentelemetry_proto::transform::trace::tonic::group_spans_by_resource_and_scope;

opentelemetry-otlp/src/lib.rs

@@ -262,7 +262,7 @@ pub use crate::exporter::{
     OTEL_EXPORTER_OTLP_TIMEOUT_DEFAULT,
 };
 
-use opentelemetry_sdk::export::ExportError;
+use opentelemetry_sdk::ExportError;
 
 /// Type to indicate the builder does not have a client set.
 #[derive(Debug, Default, Clone)]

opentelemetry-otlp/src/span.rs

@@ -5,7 +5,7 @@
 use std::fmt::Debug;
 
 use futures_core::future::BoxFuture;
-use opentelemetry_sdk::export::trace::{ExportResult, SpanData};
+use opentelemetry_sdk::trace::{ExportResult, SpanData};
 
 #[cfg(feature = "grpc-tonic")]
 use crate::{
@@ -107,7 +107,7 @@ impl HasHttpConfig for SpanExporterBuilder<HttpExporterBuilderSet> {
 
 /// OTLP exporter that sends tracing information
 #[derive(Debug)]
-pub struct SpanExporter(Box<dyn opentelemetry_sdk::export::trace::SpanExporter>);
+pub struct SpanExporter(Box<dyn opentelemetry_sdk::trace::SpanExporter>);
 
 impl SpanExporter {
     /// Obtain a builder to configure a [SpanExporter].
@@ -116,12 +116,12 @@ impl SpanExporter {
     }
 
     /// Build a new span exporter from a client
-    pub fn new(client: impl opentelemetry_sdk::export::trace::SpanExporter + 'static) -> Self {
+    pub fn new(client: impl opentelemetry_sdk::trace::SpanExporter + 'static) -> Self {
         SpanExporter(Box::new(client))
     }
 }
 
-impl opentelemetry_sdk::export::trace::SpanExporter for SpanExporter {
+impl opentelemetry_sdk::trace::SpanExporter for SpanExporter {
     fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, ExportResult> {
         self.0.export(batch)
     }

opentelemetry-otlp/tests/integration_test/tests/logs.rs

@@ -46,20 +46,36 @@ fn init_logs(is_simple: bool) -> Result<sdklogs::LoggerProvider> {
     Ok(logger_provider)
 }
 
-async fn logs_tokio_helper(is_simple: bool) -> Result<()> {
+async fn logs_tokio_helper(is_simple: bool, log_send_outside_rt: bool) -> Result<()> {
     use crate::{assert_logs_results_contains, init_logs};
     test_utils::start_collector_container().await?;
 
     let logger_provider = init_logs(is_simple).unwrap();
     let layer = OpenTelemetryTracingBridge::new(&logger_provider);
-    let subscriber = tracing_subscriber::registry().with(layer);
     // generate a random uuid and store it to expected guid
-    let expected_uuid = Uuid::new_v4().to_string();
+    let expected_uuid = std::sync::Arc::new(Uuid::new_v4().to_string());
     {
-        let _guard = tracing::subscriber::set_default(subscriber);
-        info!(target: "my-target",  uuid = expected_uuid, "hello from {}. My price is {}.", "banana", 2.99);
+        let clone_uuid = expected_uuid.clone();
+        if log_send_outside_rt {
+            std::thread::spawn(move || {
+                let subscriber = tracing_subscriber::registry().with(layer);
+                let _guard = tracing::subscriber::set_default(subscriber);
+                info!(
+                    target: "my-target",
+                    uuid = clone_uuid.as_str(),
+                    "hello from {}. My price is {}.",
+                    "banana",
+                    2.99
+                );
+            })
+            .join()
+            .unwrap();
+        } else {
+            let subscriber = tracing_subscriber::registry().with(layer);
+            let _guard = tracing::subscriber::set_default(subscriber);
+            info!(target: "my-target",  uuid = expected_uuid.as_str(), "hello from {}. My price is {}.", "banana", 2.99);
+        }
     }
-
     let _ = logger_provider.shutdown();
     tokio::time::sleep(Duration::from_secs(5)).await;
     assert_logs_results_contains(test_utils::LOGS_FILE, expected_uuid.as_str())?;
@@ -152,70 +168,183 @@ mod logtests {
 
     // Batch Processor
 
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - Tonic, Reqwest-blocking
+    // Worker threads - 4
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub async fn logs_batch_tokio_multi_thread() -> Result<()> {
-        logs_tokio_helper(false).await
+        logs_tokio_helper(false, false).await
     }
 
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - Tonic, Reqwest-blocking
+    // Worker threads - 1
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub async fn logs_batch_tokio_multi_with_one_worker() -> Result<()> {
-        logs_tokio_helper(false).await
+        logs_tokio_helper(false, false).await
     }
 
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - Tonic, Reqwest-blocking
+    // current thread
     #[tokio::test(flavor = "current_thread")]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub async fn logs_batch_tokio_current() -> Result<()> {
-        logs_tokio_helper(false).await
+        logs_tokio_helper(false, false).await
     }
 
+    // logger initialization - Inside RT
+    // Log emission - Outside RT
+    // Client - Tonic, Reqwest-blocking
+    // Worker threads - 4
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+    pub async fn logs_batch_tokio_log_outside_rt_multi_thread() -> Result<()> {
+        logs_tokio_helper(false, true).await
+    }
+
+    // logger initialization - Inside RT
+    // log emission - Outside RT
+    // Client - Tonic, Reqwest-blocking
+    // Worker threads - 1
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+    pub async fn logs_batch_tokio_log_outside_rt_multi_with_one_worker() -> Result<()> {
+        logs_tokio_helper(false, true).await
+    }
+
+    // logger initialization - Inside RT
+    // log emission - Outside RT
+    // Client - Tonic, Reqwest-blocking
+    // current thread
+    #[tokio::test(flavor = "current_thread")]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+    pub async fn logs_batch_tokio_log_outside_rt_current_thread() -> Result<()> {
+        logs_tokio_helper(false, true).await
+    }
+
+    // logger initialization  - Inside RT
+    // Log emission - Inside RT
+    // Client - Tonic, Reqwest-blocking
+    // current thread
     #[test]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub fn logs_batch_non_tokio_main_init_logs_inside_rt() -> Result<()> {
         logs_non_tokio_helper(false, true)
     }
 
+    // logger initialization - Outside RT
+    // log emission - Outside RT
+    // Client - Tonic, Reqwest-blocking
+    // current thread
     #[test]
     #[cfg(feature = "reqwest-blocking-client")]
     pub fn logs_batch_non_tokio_main_with_init_logs_outside_rt() -> Result<()> {
         logs_non_tokio_helper(false, false)
     }
 
-    // Simple Processor
+    // logger initialization - Inside RT
+    // log emission - Outside RT
+    // Client - Tonic, Reqwest-blocking
+    // current thread
+    #[test]
+    #[cfg(feature = "reqwest-blocking-client")]
+    pub fn logs_batch_non_tokio_main_with_init_logs_inside_rt() -> Result<()> {
+        logs_non_tokio_helper(false, true)
+    }
+
+    // **Simple Processor**
 
+    // logger initialization - Inside RT
+    // log emission - Outside RT
+    // Client - Tonic, Reqwest-blocking
     #[test]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub fn logs_simple_non_tokio_main_with_init_logs_inside_rt() -> Result<()> {
         logs_non_tokio_helper(true, true)
     }
 
+    // logger initialization - Inside RT
+    // log emission - Outside RT
+    // Client - reqwest, hyper
+    #[ignore] // request and hyper client does not work without tokio runtime
     #[test]
-    #[cfg(any(feature = "reqwest-blocking-client"))]
+    #[cfg(any(feature = "reqwest-client", feature = "hyper-client"))]
+    pub fn logs_simple_non_tokio_main_with_init_logs_inside_rt() -> Result<()> {
+        logs_non_tokio_helper(true, true)
+    }
+
+    // logger initialization - Outside RT
+    // log emission - Outside RT
+    // Client - Reqwest-blocking
+    #[test]
+    #[cfg(feature = "reqwest-blocking-client")]
+    pub fn logs_simple_non_tokio_main_with_init_logs_outsie_rt() -> Result<()> {
+        logs_non_tokio_helper(true, false)
+    }
+
+    // logger initialization - Outside RT
+    // log emission - Outside RT
+    // Client - hyper, tonic, reqwest
+    #[ignore] // request, tonic and hyper client does not work without tokio runtime
+    #[test]
+    #[cfg(any(
+        feature = "hyper-client",
+        feature = "tonic-client",
+        feature = "reqwest-client"
+    ))]
     pub fn logs_simple_non_tokio_main_with_init_logs_outsie_rt() -> Result<()> {
         logs_non_tokio_helper(true, false)
     }
 
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - reqwest-blocking
+    // Worker threads - 4
+    #[ignore] // request-blocking client does not work with tokio
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    #[cfg(feature = "reqwest-blocking-client")]
+    pub async fn logs_simple_tokio_multi_thread() -> Result<()> {
+        logs_tokio_helper(true, false).await
+    }
+
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - Tonic, Reqwest, hyper
+    // Worker threads - 4
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     #[cfg(any(
         feature = "tonic-client",
         feature = "reqwest-client",
         feature = "hyper-client"
     ))]
     pub async fn logs_simple_tokio_multi_thread() -> Result<()> {
-        logs_tokio_helper(true).await
+        logs_tokio_helper(true, false).await
     }
 
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - Tonic, Reqwest, hyper
+    // Worker threads - 1
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     #[cfg(any(
         feature = "tonic-client",
         feature = "reqwest-client",
         feature = "hyper-client"
     ))]
     pub async fn logs_simple_tokio_multi_with_one_worker() -> Result<()> {
-        logs_tokio_helper(true).await
+        logs_tokio_helper(true, false).await
     }
 
+    // logger initialization - Inside RT
+    // log emission - Inside RT
+    // Client - Tonic, Reqwest, hyper
+    // Current thread
     #[ignore] // https://github.com/open-telemetry/opentelemetry-rust/issues/2539
     #[tokio::test(flavor = "current_thread")]
     #[cfg(any(
@@ -224,7 +353,7 @@ mod logtests {
         feature = "hyper-client"
     ))]
     pub async fn logs_simple_tokio_current() -> Result<()> {
-        logs_tokio_helper(true).await
+        logs_tokio_helper(true, false).await
     }
 }
 ///

opentelemetry-proto/src/transform/trace.rs

@@ -8,7 +8,7 @@ pub mod tonic {
     };
     use opentelemetry::trace;
     use opentelemetry::trace::{Link, SpanId, SpanKind};
-    use opentelemetry_sdk::export::trace::SpanData;
+    use opentelemetry_sdk::trace::SpanData;
     use std::collections::HashMap;
 
     impl From<SpanKind> for span::SpanKind {
@@ -45,8 +45,8 @@ pub mod tonic {
             }
         }
     }
-    impl From<opentelemetry_sdk::export::trace::SpanData> for Span {
-        fn from(source_span: opentelemetry_sdk::export::trace::SpanData) -> Self {
+    impl From<opentelemetry_sdk::trace::SpanData> for Span {
+        fn from(source_span: opentelemetry_sdk::trace::SpanData) -> Self {
             let span_kind: span::SpanKind = source_span.span_kind.into();
             Span {
                 trace_id: source_span.span_context.trace_id().to_bytes().to_vec(),
@@ -198,8 +198,8 @@ mod tests {
     };
     use opentelemetry::InstrumentationScope;
     use opentelemetry::KeyValue;
-    use opentelemetry_sdk::export::trace::SpanData;
     use opentelemetry_sdk::resource::Resource;
+    use opentelemetry_sdk::trace::SpanData;
     use opentelemetry_sdk::trace::{SpanEvents, SpanLinks};
     use std::borrow::Cow;
     use std::time::{Duration, SystemTime};

opentelemetry-proto/src/transform/tracez.rs

@@ -1,7 +1,7 @@
 #[cfg(all(feature = "gen-tonic-messages", feature = "zpages"))]
 mod tonic {
     use opentelemetry::trace::{Event, Status};
-    use opentelemetry_sdk::export::trace::SpanData;
+    use opentelemetry_sdk::trace::SpanData;
 
     use crate::proto::tonic::{
         trace::v1::{span::Event as SpanEvent, Status as SpanStatus},