Merge branch 'main' into feat/opentelemetry-sdk/version-number-constant

Author: the-wondersmith

.cspell.json

@@ -64,6 +64,7 @@
         "shoppingcart",
         "struct",
         "Tescher",
+        "testcontainers",
         "testresults",
         "thiserror",
         "tracerprovider",

opentelemetry-otlp/tests/integration_test/Cargo.toml

@@ -14,6 +14,7 @@ testcontainers = { version = "0.23.1", features = ["http_wait"]}
 once_cell.workspace = true
 anyhow = "1.0.94"
 ctor = "0.2.9"
+uuid = { version = "1.3", features = ["v4"] }
 tracing-subscriber = { workspace = true, features = ["env-filter","registry", "std", "fmt"] }
 tracing = {workspace = true}
 

opentelemetry-otlp/tests/integration_test/src/test_utils.rs

@@ -52,7 +52,7 @@ fn init_tracing() {
         // Initialize the tracing subscriber with the OpenTelemetry layer and the
         // Fmt layer.
         tracing_subscriber::registry().with(fmt_layer).init();
-        otel_info!(name: "tracing initializing completed!");
+        otel_info!(name: "tracing::fmt initializing completed! SDK internal logs will be printed to stdout.");
     });
 }
 

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

@@ -2,15 +2,14 @@
 
 use anyhow::Result;
 use ctor::dtor;
-use integration_test_runner::logs_asserter::{read_logs_from_json, LogsAsserter};
 use integration_test_runner::test_utils;
 use opentelemetry_otlp::LogExporter;
 use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::{logs as sdklogs, Resource};
 use std::fs::File;
-use std::os::unix::fs::MetadataExt;
+use std::io::Read;
 
-fn init_logs() -> Result<sdklogs::LoggerProvider> {
+fn init_logs(is_simple: bool) -> Result<sdklogs::LoggerProvider> {
     let exporter_builder = LogExporter::builder();
     #[cfg(feature = "tonic-client")]
     let exporter_builder = exporter_builder.with_tonic();
@@ -24,24 +23,43 @@ fn init_logs() -> Result<sdklogs::LoggerProvider> {
 
     let exporter = exporter_builder.build()?;
 
-    Ok(LoggerProvider::builder()
-        .with_batch_exporter(exporter)
+    let mut logger_provider_builder = LoggerProvider::builder();
+    if is_simple {
+        logger_provider_builder = logger_provider_builder.with_simple_exporter(exporter)
+    } else {
+        logger_provider_builder = logger_provider_builder.with_batch_exporter(exporter)
+    };
+
+    let logger_provider = logger_provider_builder
         .with_resource(
             Resource::builder_empty()
                 .with_service_name("logs-integration-test")
                 .build(),
         )
-        .build())
+        .build();
+
+    Ok(logger_provider)
 }
 
 #[cfg(test)]
 mod logtests {
+    // TODO: The tests in this mod works like below: Emit a log with a UUID,
+    // then read the logs from the file and check if the UUID is present in the
+    // logs. This makes it easy to validate with a single collector and its
+    // output. This is a very simple test but good enough to validate that OTLP
+    // Exporter did work! A more comprehensive test would be to validate the
+    // entire Payload. The infra for it already exists (logs_asserter.rs), the
+    // TODO here is to write a test that validates the entire payload.
+
     use super::*;
     use integration_test_runner::logs_asserter::{read_logs_from_json, LogsAsserter};
+    use integration_test_runner::test_utils;
+    use opentelemetry_appender_tracing::layer;
     use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
     use std::{fs::File, time::Duration};
     use tracing::info;
     use tracing_subscriber::layer::SubscriberExt;
+    use uuid::Uuid;
 
     #[test]
     #[should_panic(expected = "assertion `left == right` failed: body does not match")]
@@ -68,41 +86,91 @@ mod logtests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    #[cfg(not(feature = "hyper-client"))]
-    #[cfg(not(feature = "reqwest-client"))]
-    pub async fn test_logs() -> Result<()> {
-        // Make sure the container is running
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+    pub async fn logs_batch_tokio_multi_thread() -> Result<()> {
+        logs_batch_tokio_helper().await
+    }
 
-        use integration_test_runner::test_utils;
-        use opentelemetry_appender_tracing::layer;
-        use tracing::info;
-        use tracing_subscriber::layer::SubscriberExt;
+    #[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_batch_tokio_helper().await
+    }
 
+    #[tokio::test(flavor = "current_thread")]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+    pub async fn logs_batch_tokio_current() -> Result<()> {
+        logs_batch_tokio_helper().await
+    }
+
+    async fn logs_batch_tokio_helper() -> Result<()> {
         use crate::{assert_logs_results, init_logs};
         test_utils::start_collector_container().await?;
 
-        let logger_provider = init_logs().unwrap();
-        let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider);
+        let logger_provider = init_logs(false).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 _guard = tracing::subscriber::set_default(subscriber);
-            info!(target: "my-target", "hello from {}. My price is {}.", "banana", 2.99);
+            info!(target: "my-target",  uuid = expected_uuid, "hello from {}. My price is {}.", "banana", 2.99);
         }
-        // TODO: remove below wait before calling logger_provider.shutdown()
-        // tokio::time::sleep(Duration::from_secs(10)).await;
+
         let _ = logger_provider.shutdown();
+        tokio::time::sleep(Duration::from_secs(5)).await;
+        assert_logs_results(test_utils::LOGS_FILE, expected_uuid.as_str())?;
+        Ok(())
+    }
 
-        tokio::time::sleep(Duration::from_secs(10)).await;
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-client"))]
+    pub async fn logs_simple_tokio_multi_thread() -> Result<()> {
+        logs_simple_tokio_helper().await
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-client"))]
+    pub async fn logs_simple_tokio_multi_with_one_worker() -> Result<()> {
+        logs_simple_tokio_helper().await
+    }
+
+    // Ignored, to be investigated
+    #[ignore]
+    #[tokio::test(flavor = "current_thread")]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-client"))]
+    pub async fn logs_simple_tokio_current() -> Result<()> {
+        logs_simple_tokio_helper().await
+    }
+
+    async fn logs_simple_tokio_helper() -> Result<()> {
+        use crate::{assert_logs_results, init_logs};
+        test_utils::start_collector_container().await?;
 
-        assert_logs_results(test_utils::LOGS_FILE, "expected/logs.json")?;
+        let logger_provider = init_logs(true).unwrap();
+        let layer = OpenTelemetryTracingBridge::new(&logger_provider);
+        let subscriber = tracing_subscriber::registry().with(layer);
+        info!("Tracing initialized");
+        // generate a random uuid and store it to expected guid
+        let expected_uuid = 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 _ = logger_provider.shutdown();
+        tokio::time::sleep(Duration::from_secs(5)).await;
+        assert_logs_results(test_utils::LOGS_FILE, expected_uuid.as_str())?;
         Ok(())
     }
 
-    #[ignore = "TODO: [Fix Me] Failing on CI. Needs to be investigated and resolved."]
     #[test]
     #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
     pub fn logs_batch_non_tokio_main() -> Result<()> {
+        logs_batch_non_tokio_helper()
+    }
+
+    fn logs_batch_non_tokio_helper() -> Result<()> {
         // Initialize the logger provider inside a tokio runtime
         // as this allows tonic client to capture the runtime,
         // but actual export occurs from the dedicated std::thread
@@ -111,31 +179,61 @@ mod logtests {
         let logger_provider = rt.block_on(async {
             // While we're here setup our collector container too, as this needs tokio to run
             test_utils::start_collector_container().await?;
-            init_logs()
+            init_logs(false)
         })?;
-
-        info!("LoggerProvider created");
-        let layer = OpenTelemetryTracingBridge::new(&logger_provider);
+        let layer = 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 _guard = tracing::subscriber::set_default(subscriber);
-            info!(target: "my-target", "hello from {}. My price is {}.", "banana", 2.99);
+            info!(target: "my-target",  uuid = expected_uuid, "hello from {}. My price is {}.", "banana", 2.99);
         }
-        let _ = logger_provider.shutdown();
-        // tokio::time::sleep(Duration::from_secs(10)).await;
-        assert_logs_results(test_utils::LOGS_FILE, "expected/logs.json")?;
 
+        let _ = logger_provider.shutdown();
+        std::thread::sleep(Duration::from_secs(5));
+        assert_logs_results(test_utils::LOGS_FILE, expected_uuid.as_str())?;
         Ok(())
     }
-}
 
-pub fn assert_logs_results(result: &str, expected: &str) -> Result<()> {
-    let left = read_logs_from_json(File::open(expected)?)?;
-    let right = read_logs_from_json(File::open(result)?)?;
+    #[test]
+    #[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+    pub fn logs_simple_non_tokio_main() -> Result<()> {
+        logs_simple_non_tokio_helper()
+    }
 
-    LogsAsserter::new(left, right).assert();
+    fn logs_simple_non_tokio_helper() -> Result<()> {
+        // Initialize the logger provider inside a tokio runtime
+        // as this allows tonic client to capture the runtime,
+        // but actual export occurs from the main non-tokio thread.
+        let rt = tokio::runtime::Runtime::new()?;
+        let logger_provider = rt.block_on(async {
+            // While we're here setup our collector container too, as this needs tokio to run
+            test_utils::start_collector_container().await?;
+            init_logs(true)
+        })?;
+        let layer = 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 _guard = tracing::subscriber::set_default(subscriber);
+            info!(target: "my-target",  uuid = expected_uuid, "hello from {}. My price is {}.", "banana", 2.99);
+        }
+
+        let _ = logger_provider.shutdown();
+        std::thread::sleep(Duration::from_secs(5));
+        assert_logs_results(test_utils::LOGS_FILE, expected_uuid.as_str())?;
+        Ok(())
+    }
+}
 
-    assert!(File::open(result).unwrap().metadata().unwrap().size() > 0);
+pub fn assert_logs_results(result: &str, expected_content: &str) -> Result<()> {
+    let file = File::open(result)?;
+    let mut contents = String::new();
+    let mut reader = std::io::BufReader::new(&file);
+    reader.read_to_string(&mut contents)?;
+    assert!(contents.contains(expected_content));
     Ok(())
 }
 

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

@@ -189,9 +189,8 @@ pub fn validate_metrics_against_results(scope_name: &str) -> Result<()> {
 /// TODO - fix this asynchronously.
 ///
 #[cfg(test)]
-#[cfg(not(feature = "hyper-client"))]
-#[cfg(not(feature = "reqwest-client"))]
-mod tests {
+#[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
+mod metrictests {
 
     use super::*;
     use opentelemetry::metrics::MeterProvider;
@@ -246,7 +245,6 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    // #[ignore] // skip when running unit test
     async fn test_histogram() -> Result<()> {
         _ = setup_metrics_test().await;
         const METER_NAME: &str = "test_histogram_meter";
@@ -263,7 +261,6 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    // #[ignore] // skip when running unit test
     async fn test_up_down_counter() -> Result<()> {
         _ = setup_metrics_test().await;
         const METER_NAME: &str = "test_up_down_meter";

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

@@ -48,6 +48,7 @@ const LEMONS_KEY: Key = Key::from_static_str("lemons");
 const ANOTHER_KEY: Key = Key::from_static_str("ex.com/another");
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+#[cfg(any(feature = "tonic-client", feature = "reqwest-blocking-client"))]
 pub async fn traces() -> Result<()> {
     test_utils::start_collector_container().await?;