test(rust): execute logging / tracing tests as integration tests

Those tests need to be isolated since they set some global exporters

Author: etorreborre

implementations/rust/ockam/ockam_api/src/cli_state/cli_state.rs

@@ -155,7 +155,7 @@ impl CliState {
 /// Low-level functions for creating / deleting CliState files
 impl CliState {
     /// Create a new CliState where the data is stored at a given path
-    pub(super) async fn create(dir: PathBuf) -> Result<Self> {
+    pub async fn create(dir: PathBuf) -> Result<Self> {
         std::fs::create_dir_all(&dir)?;
         let database = SqlxDatabase::create(Self::make_database_path(&dir)).await?;
         let application_database = SqlxDatabase::create_with_migration(

implementations/rust/ockam/ockam_api/src/cli_state/journeys/journeys.rs

@@ -167,82 +167,3 @@ impl CliState {
         (opentelemetry_context, now)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::logs::{LoggingConfiguration, LoggingTracing};
-    use crate::random_name;
-    use ockam_node::Executor;
-    use opentelemetry::trace::FutureExt;
-    use opentelemetry_sdk::testing::logs::InMemoryLogsExporter;
-    use opentelemetry_sdk::testing::trace::InMemorySpanExporter;
-    use tempfile::NamedTempFile;
-
-    #[test]
-    fn test_create_journey_event() {
-        let spans_exporter = InMemorySpanExporter::default();
-        let logs_exporter = InMemoryLogsExporter::default();
-
-        let tracing_guard = LoggingTracing::setup_with_exporters(
-            spans_exporter.clone(),
-            logs_exporter.clone(),
-            None,
-            LoggingConfiguration::off().set_crates(&["ockam_api"]),
-            "test",
-        );
-        let tracer = global::tracer("ockam-test");
-        let result = tracer.in_span("user event", |cx| {
-            let _guard = cx.with_value(Utc::now()).attach();
-
-            Executor::execute_future(
-                async move {
-                    let db_file = NamedTempFile::new().unwrap();
-                    let cli_state_directory = db_file.path().parent().unwrap().join(random_name());
-                    let cli = CliState::create(cli_state_directory)
-                        .await
-                        .unwrap()
-                        .set_tracing_enabled();
-
-                    let mut map = HashMap::new();
-                    map.insert(USER_EMAIL, "[email protected]");
-                    map.insert(USER_NAME, "eric");
-                    cli.add_journey_event(JourneyEvent::Enrolled, map.clone())
-                        .await
-                        .unwrap();
-                    cli.add_journey_event(JourneyEvent::PortalCreated, map)
-                        .await
-                        .unwrap();
-                }
-                .with_current_context(),
-            )
-        });
-        assert!(result.is_ok());
-
-        tracing_guard.force_flush();
-        let mut spans = spans_exporter.get_finished_spans().unwrap();
-        spans.sort_by_key(|s| s.start_time);
-        assert_eq!(spans.len(), 4);
-
-        let span_names = spans.iter().map(|s| s.name.as_ref()).collect::<Vec<&str>>();
-        assert_eq!(
-            span_names,
-            vec![
-                "user event",
-                "start host journey",
-                "enrolled",
-                "portal created"
-            ]
-        );
-        // remove the first event
-        spans.remove(0);
-
-        // all user events have the same start/end times and have a duration of 1ms
-        let first_span = spans.first().unwrap().clone();
-        for span in spans {
-            assert_eq!(span.start_time, first_span.start_time);
-            assert_eq!(span.end_time, first_span.end_time);
-            assert_eq!(span.start_time.add(Duration::from_millis(1)), span.end_time);
-        }
-    }
-}

implementations/rust/ockam/ockam_api/src/logs/logging_configuration.rs

@@ -15,7 +15,7 @@ pub struct LoggingConfiguration {
     format: LogFormat,
     colored: Colored,
     log_dir: Option<PathBuf>,
-    crates: Vec<String>,
+    crates: Option<Vec<String>>,
 }
 
 impl LoggingConfiguration {
@@ -28,7 +28,7 @@ impl LoggingConfiguration {
         format: LogFormat,
         colored: Colored,
         log_dir: Option<PathBuf>,
-        crates: &[&str],
+        crates: Option<&[&str]>,
     ) -> LoggingConfiguration {
         LoggingConfiguration {
             level,
@@ -38,7 +38,7 @@ impl LoggingConfiguration {
             format,
             colored,
             log_dir,
-            crates: crates.iter().map(|c| c.to_string()).collect(),
+            crates: crates.map(|cs| cs.iter().map(|c| c.to_string()).collect()),
         }
     }
 
@@ -70,7 +70,7 @@ impl LoggingConfiguration {
         self.log_dir.clone()
     }
 
-    pub fn crates(&self) -> Vec<String> {
+    pub fn crates(&self) -> Option<Vec<String>> {
         self.crates.clone()
     }
 
@@ -83,22 +83,27 @@ impl LoggingConfiguration {
 
     pub fn set_crates(self, crates: &[&str]) -> LoggingConfiguration {
         LoggingConfiguration {
-            crates: crates.iter().map(|c| c.to_string()).collect(),
+            crates: Some(crates.iter().map(|c| c.to_string()).collect()),
             ..self
         }
     }
 
     pub fn env_filter(&self) -> EnvFilter {
-        let builder = EnvFilter::builder();
-        builder
-            .with_default_directive(self.level().into())
-            .parse_lossy(
-                self.crates()
-                    .iter()
-                    .map(|c| format!("{c}={}", self.level()))
-                    .collect::<Vec<_>>()
-                    .join(","),
-            )
+        match &self.crates {
+            Some(crates) => {
+                let builder = EnvFilter::builder();
+                builder
+                    .with_default_directive(self.level().into())
+                    .parse_lossy(
+                        crates
+                            .iter()
+                            .map(|c| format!("{c}={}", self.level()))
+                            .collect::<Vec<_>>()
+                            .join(","),
+                    )
+            }
+            None => EnvFilter::default().add_directive(self.level.into()),
+        }
     }
 
     pub fn off() -> LoggingConfiguration {
@@ -110,7 +115,7 @@ impl LoggingConfiguration {
             LogFormat::Default,
             Colored::Off,
             None,
-            &[],
+            None,
         )
     }
 
@@ -123,20 +128,20 @@ impl LoggingConfiguration {
             log_format(),
             Colored::Off,
             log_dir,
-            crates,
+            Some(crates),
         )
     }
 
-    fn default_crates() -> Vec<String> {
-        vec![
-            "ockam".to_string(),
-            "ockam_node".to_string(),
-            "ockam_core".to_string(),
-            "ockam_vault".to_string(),
-            "ockam_identity".to_string(),
-            "ockam_transport_tcp".to_string(),
-            "ockam_api".to_string(),
-            "ockam_command".to_string(),
+    pub fn default_crates() -> &'static [&'static str] {
+        &[
+            "ockam",
+            "ockam_node",
+            "ockam_core",
+            "ockam_vault",
+            "ockam_identity",
+            "ockam_transport_tcp",
+            "ockam_api",
+            "ockam_command",
         ]
     }
 }
@@ -151,10 +156,7 @@ impl Default for LoggingConfiguration {
             LogFormat::Default,
             Colored::Off,
             None,
-            &LoggingConfiguration::default_crates()
-                .iter()
-                .map(|c| c.as_str())
-                .collect::<Vec<&str>>(),
+            None,
         )
     }
 }
@@ -225,7 +227,7 @@ pub fn new_logging_configuration(
         log_format(),
         colored,
         log_dir,
-        crates,
+        Some(crates),
     )
 }
 
@@ -275,7 +277,7 @@ fn legacy_logging_configuration(
             format: log_format(),
             colored,
             log_dir,
-            crates: crates.iter().map(|c| c.to_string()).collect(),
+            crates: Some(crates.iter().map(|c| c.to_string()).collect()),
         })
 }
 

implementations/rust/ockam/ockam_api/src/logs/setup.rs

@@ -334,86 +334,6 @@ impl std::fmt::Display for LogFormat {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use crate::logs::{LoggingConfiguration, LoggingTracing};
-    use crate::random_name;
-    use opentelemetry::global;
-    use opentelemetry::trace::Tracer;
-    use opentelemetry_sdk::{self as sdk};
-    use sdk::testing::logs::*;
-    use sdk::testing::trace::*;
-    use std::fs;
-    use tempfile::NamedTempFile;
-
-    #[test]
-    fn test_log_and_traces() {
-        let temp_file = NamedTempFile::new().unwrap();
-        let log_directory = &temp_file.path().parent().unwrap().join(random_name());
-
-        let spans_exporter = InMemorySpanExporter::default();
-        let logs_exporter = InMemoryLogsExporter::default();
-        let ockam_crates = &["ockam_api"];
-        let guard = LoggingTracing::setup_with_exporters(
-            spans_exporter.clone(),
-            logs_exporter.clone(),
-            None,
-            LoggingConfiguration::default()
-                .set_log_directory(log_directory.into())
-                .set_crates(ockam_crates),
-            "test",
-        );
-
-        let tracer = global::tracer("ockam-test");
-        tracer.in_span("Logging::test", |_| {
-            info!("inside span");
-            error!("something went wrong!");
-        });
-
-        // check that the spans are exported
-        guard.force_flush();
-        let spans = spans_exporter.get_finished_spans().unwrap();
-        assert_eq!(spans.len(), 1);
-        let parent_span = spans.first().unwrap();
-
-        // check that log records are exported
-        let logs = logs_exporter.get_emitted_logs().unwrap();
-        assert_eq!(logs.len(), 2);
-        for log in logs {
-            assert_eq!(
-                log.clone().record.trace_context.map(|tc| tc.trace_id),
-                Some(parent_span.span_context.trace_id()),
-                "{log:?}\n{parent_span:?}"
-            )
-        }
-
-        // read the content of the log file to make sure that log messages are there
-        let mut stdout_file_checked = false;
-        for file in fs::read_dir(log_directory).unwrap() {
-            let file_path = file.unwrap().path();
-            if file_path.to_string_lossy().contains("stdout") {
-                let contents = fs::read_to_string(file_path).unwrap();
-                assert!(
-                    contents.contains("INFO ockam_api::logs::setup::tests: inside span"),
-                    "{:?}",
-                    contents
-                );
-                assert!(
-                    contents.contains("ERROR ockam_api::logs::setup::tests: something went wrong!"),
-                    "{:?}",
-                    contents
-                );
-                stdout_file_checked = true
-            }
-        }
-
-        assert!(
-            stdout_file_checked,
-            "the stdout log file must have been found and checked"
-        )
-    }
-}
-
 #[derive(Debug)]
 struct DecoratedLogExporter<L: LogExporter> {
     exporter: L,