Migrate testcontainers forward so we can use wait_for with a http check

Author: scottgerring

opentelemetry-otlp/tests/integration_test/Cargo.toml

@@ -11,7 +11,7 @@ opentelemetry-proto = { path = "../../../opentelemetry-proto", features = ["gen-
 log = { workspace = true }
 tokio = { version = "1.0", features = ["full"] }
 serde_json = "1"
-testcontainers = "0.15.0"
+testcontainers = { version = "0.23.1", features = ["http_wait"]}
 once_cell.workspace = true
 anyhow = "1.0.94"
 ctor = "0.2.9"

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

@@ -19,22 +19,19 @@
 #![cfg(unix)]
 
 use std::collections::HashMap;
+use std::fs;
 use std::fs::File;
 use std::os::unix::fs::PermissionsExt;
 use std::sync::{Arc, Mutex, Once, OnceLock};
-use testcontainers::clients::Cli;
-use testcontainers::core::{Port, WaitFor};
-use testcontainers::{Container, Image, RunnableImage};
+use testcontainers::{core::{IntoContainerPort, WaitFor}, runners::AsyncRunner, ContainerAsync, GenericImage, ImageExt};
+use testcontainers::core::{ContainerPort, Mount};
+use testcontainers::core::wait::HttpWaitStrategy;
 use tracing_subscriber::FmtSubscriber;
 use opentelemetry::{otel_debug, otel_info};
+use anyhow::Result;
 
 // Static references for container management
-static COLLECTOR_ARC: OnceLock<Mutex<Option<Arc<Container<Collector>>>>> = OnceLock::new();
-static DOCKER_CLIENT: OnceLock<Cli> = OnceLock::new();
-
-fn init_docker_client() -> Cli {
-    Cli::default()
-}
+static COLLECTOR_ARC: OnceLock<Mutex<Option<Arc<ContainerAsync<GenericImage>>>>> = OnceLock::new();
 
 pub static METRICS_FILE: &str = "./actual/metrics.json";
 pub static LOGS_FILE: &str = "./actual/logs.json";
@@ -54,10 +51,9 @@ fn init_tracing() {
     });
 }
 
-pub async fn start_collector_container() {
+pub async fn start_collector_container() -> Result<()> {
     init_tracing();
 
-    let docker = DOCKER_CLIENT.get_or_init(init_docker_client);
     let mut arc_guard = COLLECTOR_ARC
         .get_or_init(|| Mutex::new(None))
         .lock()
@@ -71,24 +67,33 @@ pub async fn start_collector_container() {
         upsert_empty_file(LOGS_FILE);
 
         // Start a new container
-        let image = Collector::default();
-        let runnable_image =
-            RunnableImage::from(image)
-                .with_mapped_port(Port::from((4317, 4317)))
-                .with_mapped_port(Port::from((4318, 4318)));
+        let container_instance = GenericImage::new("otel/opentelemetry-collector", "latest")
+            .with_wait_for(WaitFor::http(
+                HttpWaitStrategy::new("/")
+                    .with_expected_status_code(404u16)
+                    .with_port(ContainerPort::Tcp(4318))))
+            .with_mapped_port(4317, ContainerPort::Tcp(4317))
+            .with_mapped_port(4318, ContainerPort::Tcp(4318))
+            .with_mount(Mount::bind_mount(fs::canonicalize("./otel-collector-config.yaml")?.to_string_lossy(), "/etc/otelcol/config.yaml"))
+            .with_mount(Mount::bind_mount(fs::canonicalize("./actual/logs.json")?.to_string_lossy(), "/testresults/logs.json"))
+            .with_mount(Mount::bind_mount(fs::canonicalize("./actual/metrics.json")?.to_string_lossy(), "/testresults/metrics.json"))
+            .with_mount(Mount::bind_mount(fs::canonicalize("./actual/traces.json")?.to_string_lossy(), "/testresults/traces.json"))
+            .start()
+            .await?;
 
-        let container_instance = docker.run(runnable_image);
         let container = Arc::new(container_instance);
         otel_debug!(
             name: "Container started",
-            ports = format!("{:?}", container.ports()));
+            ports = format!("{:?}", container.ports().await));
 
         // Give the container a second to stabilize
-        tokio::time::sleep(std::time::Duration::from_secs(5)).await;
+        //tokio::time::sleep(std::time::Duration::from_secs(5)).await;
 
         // Store the container in COLLECTOR_ARC
         *arc_guard = Some(Arc::clone(&container));
     }
+
+    Ok(())
 }
 
 ///
@@ -116,43 +121,3 @@ pub fn stop_collector_container() {
         otel_debug!(name: "stop_collector_container::stopped");
     }
 }
-
-struct Collector {
-    volumes: HashMap<String, String>,
-}
-
-impl Image for Collector {
-    type Args = ();
-
-    fn name(&self) -> String {
-        "otel/opentelemetry-collector".to_string()
-    }
-
-    fn tag(&self) -> String {
-        "latest".to_string()
-    }
-
-    fn ready_conditions(&self) -> Vec<WaitFor> {
-        vec![WaitFor::Nothing]
-    }
-
-    fn volumes(&self) -> Box<dyn Iterator<Item = (&String, &String)> + '_> {
-        Box::new(self.volumes.iter())
-    }
-}
-
-impl Default for Collector {
-    fn default() -> Self {
-        Collector {
-            volumes: HashMap::from([
-                (
-                    "./otel-collector-config.yaml".into(),
-                    "/etc/otelcol/config.yaml".into(),
-                ),
-                (TRACES_FILE.into(), "/testresults/traces.json".into()),
-                (LOGS_FILE.into(), "/testresults/logs.json".into()),
-                (METRICS_FILE.into(), "/testresults/metrics.json".into()),
-            ]),
-        }
-    }
-}

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

@@ -6,7 +6,7 @@ use integration_test_runner::logs_asserter::{read_logs_from_json, LogsAsserter};
 use integration_test_runner::test_utils;
 use log::{info, Level};
 use opentelemetry_appender_log::OpenTelemetryLogBridge;
-use opentelemetry_otlp::{LogExporter, WithExportConfig};
+use opentelemetry_otlp::LogExporter;
 use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::{logs as sdklogs, runtime, Resource};
 use std::fs::File;
@@ -16,16 +16,14 @@ use std::time::Duration;
 fn init_logs() -> Result<sdklogs::LoggerProvider> {
     let exporter_builder = LogExporter::builder();
     #[cfg(feature = "tonic-client")]
-    let exporter_builder = exporter_builder.with_tonic()
-        .with_endpoint("http://127.0.0.1:4317");
+    let exporter_builder = exporter_builder.with_tonic();
     #[cfg(not(feature = "tonic-client"))]
     #[cfg(any(
         feature = "hyper-client",
         feature = "reqwest-client",
         feature = "reqwest-blocking-client"
     ))]
-    let exporter_builder = exporter_builder.with_http()
-        .with_endpoint("http://http://127.0.0.1:4318");
+    let exporter_builder = exporter_builder.with_http();
 
     let exporter = exporter_builder.build()?;
 
@@ -42,7 +40,7 @@ fn init_logs() -> Result<sdklogs::LoggerProvider> {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 pub async fn test_logs() -> Result<()> {
     // Make sure the container is running
-    test_utils::start_collector_container().await;
+    test_utils::start_collector_container().await?;
 
     let logger_provider = init_logs().unwrap();
     let otel_log_appender = OpenTelemetryLogBridge::new(&logger_provider);

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

@@ -139,7 +139,7 @@ pub fn fetch_latest_metrics_for_scope(scope_name: &str) -> Result<Value> {
 ///
 async fn setup_metrics_test() {
     // Make sure the collector container is running
-    start_collector_container().await;
+    start_collector_container().await?;
 
     let mut done = SETUP_DONE.lock().unwrap();
     if !*done {
@@ -275,7 +275,7 @@ mod tests {
         // and make sure our data is flushed through.
 
         // Make sure the collector is running
-        start_collector_container().await;
+        start_collector_container().await?;
 
         // Set up the exporter
         let exporter = create_exporter();

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

@@ -49,7 +49,7 @@ const ANOTHER_KEY: Key = Key::from_static_str("ex.com/another");
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 pub async fn traces() -> Result<()> {
-    test_utils::start_collector_container().await;
+    test_utils::start_collector_container().await?;
 
     let tracer_provider = init_tracer_provider().expect("Failed to initialize tracer provider.");
     global::set_tracer_provider(tracer_provider.clone());