Improve otel-smoke-test to use fake collector and also test trace propagation

Signed-off-by: Caleb Schoepp <caleb.schoepp@fermyon.com>

Author: calebschoepp

crates/runtime-config/src/lib.rs

@@ -389,12 +389,6 @@ impl FactorRuntimeConfigSource<ObserveFactor> for TomlRuntimeConfigSource<'_, '_
     }
 }
 
-impl FactorRuntimeConfigSource<ObserveFactor> for TomlRuntimeConfigSource<'_, '_> {
-    fn get_runtime_config(&mut self) -> anyhow::Result<Option<()>> {
-        Ok(None)
-    }
-}
-
 impl RuntimeConfigSourceFinalizer for TomlRuntimeConfigSource<'_, '_> {
     fn finalize(&mut self) -> anyhow::Result<()> {
         Ok(self.toml.validate_all_keys_used()?)

tests/integration.rs

@@ -155,74 +155,65 @@ mod integration_tests {
         Ok(())
     }
 
-    #[test]
-    #[cfg(feature = "extern-dependencies-tests")]
-    /// Test that basic otel tracing works
-    fn otel_smoke_test() -> anyhow::Result<()> {
-        use anyhow::Context;
+    // TODO: Cleanup the fake collectors somehow
 
-        use crate::testcases::run_test_inited;
-        run_test_inited(
-            "otel-smoke-test",
-            SpinConfig {
-                binary_path: spin_binary(),
-                spin_up_args: Vec::new(),
-                app_type: SpinAppType::Http,
-            },
-            ServicesConfig::new(vec!["jaeger"])?,
-            |env| {
-                let otel_port = env
-                    .services_mut()
-                    .get_port(4318)?
-                    .context("expected a port for Jaeger")?;
-                env.set_env_var(
-                    "OTEL_EXPORTER_OTLP_ENDPOINT",
-                    format!("http://localhost:{}", otel_port),
-                );
-                Ok(())
-            },
-            move |env| {
-                let spin = env.runtime_mut();
-                assert_spin_request(
-                    spin,
-                    Request::new(Method::Get, "/hello"),
-                    Response::new_with_body(200, "Hello, Fermyon!\n"),
-                )?;
+    #[tokio::test]
+    // Test that basic otel tracing and context propagation works
+    async fn otel_smoke_test() -> anyhow::Result<()> {
+        let collector = FakeCollectorServer::start()
+            .await
+            .expect("fake collector server should start");
+        let collector_endpoint = collector.endpoint().clone();
 
-                assert_eventually!(
-                    {
-                        let jaeger_port = env
-                            .services_mut()
-                            .get_port(16686)?
-                            .context("no jaeger port was exposed by test services")?;
-                        let url = format!("http://localhost:{jaeger_port}/api/traces?service=spin");
-                        match reqwest::blocking::get(&url).context("failed to get jaeger traces")? {
-                            resp if resp.status().is_success() => {
-                                let traces: Value =
-                                    resp.json().context("failed to parse jaeger traces")?;
-                                let traces =
-                                    traces.get("data").context("jaeger traces has no data")?;
-                                let traces =
-                                    traces.as_array().context("jaeger traces is not an array")?;
-                                !traces.is_empty()
-                            }
-                            _resp => {
-                                eprintln!("failed to get jaeger traces:");
-                                false
-                            }
-                        }
-                    },
-                    20
-                );
-                Ok(())
-            },
-        )?;
+        tokio::task::spawn_blocking(|| {
+            run_test_inited(
+                "otel-smoke-test",
+                SpinConfig {
+                    binary_path: spin_binary(),
+                    spin_up_args: Vec::new(),
+                    app_type: SpinAppType::Http,
+                },
+                ServicesConfig::none(),
+                |env| {
+                    env.set_env_var("OTEL_EXPORTER_OTLP_ENDPOINT", collector_endpoint);
+                    env.set_env_var("OTEL_EXPORTER_OTLP_TRACES_PROTOCOL", "grpc");
+                    env.set_env_var("OTEL_BSP_SCHEDULE_DELAY", "5");
+                    Ok(())
+                },
+                move |env| {
+                    let spin = env.runtime_mut();
+                    assert_spin_request(
+                        spin,
+                        Request::new(Method::Get, "/one"),
+                        Response::new(200),
+                    )?;
+
+                    let mut spans: Vec<ExportedSpan>;
+                    assert_eventually!(
+                        {
+                            spans = collector.exported_spans();
+                            !spans.is_empty()
+                        },
+                        5
+                    );
+
+                    assert_eq!(spans.len(), 5);
+
+                    // They're all part of the same trace which implies context propagation is working
+                    assert!(spans
+                        .iter()
+                        .map(|s| s.trace_id.clone())
+                        .all(|t| t == spans[0].trace_id));
+
+                    Ok(())
+                },
+            )
+        })
+        .await??;
 
         Ok(())
     }
 
-    // TODO: Cleanup the fake collectors somehow
-
     #[tokio::test]
     async fn wasi_observe_nested_spans() -> anyhow::Result<()> {
         let collector = FakeCollectorServer::start()

tests/test-components/components/Cargo.lock

@@ -0,0 +1,12 @@
+[package]
+name = "otel-smoke-test"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = "1"
+http = "0.2"
+spin-sdk = "2.2.0"

tests/test-components/components/otel-smoke-test/Cargo.toml

@@ -0,0 +1,22 @@
+use spin_sdk::{
+    http::{Method, Params, Request, Response, Router},
+    http_component,
+};
+
+#[http_component]
+fn handle(req: http::Request<()>) -> Response {
+    let mut router = Router::new();
+    router.get_async("/one", one);
+    router.get_async("/two", two);
+    router.handle(req)
+}
+
+async fn one(_req: Request, _params: Params) -> Response {
+    let req = Request::builder().method(Method::Get).uri("/two").build();
+    let _res: Response = spin_sdk::http::send(req).await.unwrap();
+    Response::new(200, "")
+}
+
+async fn two(_req: Request, _params: Params) -> Response {
+    Response::new(201, "")
+}

tests/test-components/components/otel-smoke-test/src/lib.rs

@@ -1,12 +1,13 @@
 spin_version = "1"
 authors = ["Fermyon Engineering <engineering@fermyon.com>"]
-description = "A simple application that returns hello and goodbye."
-name = "head-rust-sdk-http"
+description = "A simple application that tests otel."
+name = "otel-smoke-test"
 trigger = { type = "http" }
 version = "1.0.0"
 
 [[component]]
-id = "hello"
-source = "%{source=hello-world}"
+id = "otel"
+source = "%{source=otel-smoke-test}"
+allowed_outbound_hosts = ["http://self"]
 [component.trigger]
-route = "/hello/..."
+route = "/..."