Support adding events

Signed-off-by: Caleb Schoepp <[email protected]>

Author: calebschoepp

Cargo.lock

@@ -96,7 +96,7 @@ test-components = { path = "tests/test-components" }
 test-environment = { workspace = true }
 testing-framework = { path = "tests/testing-framework" }
 which = "4.2.5"
-fake-opentelemetry-collector = "0.19.0"
+fake-opentelemetry-collector = { path = "../../davidB/tracing-opentelemetry-instrumentation-sdk/fake-opentelemetry-collector" }
 
 [build-dependencies]
 cargo-target-dep = { git = "https://github.com/fermyon/cargo-target-dep", rev = "482f269eceb7b1a7e8fc618bf8c082dd24979cf1" }

Cargo.toml

@@ -1,11 +1,16 @@
+use std::time::Duration;
+use std::time::SystemTime;
+use std::time::UNIX_EPOCH;
+
 use anyhow::Result;
 use opentelemetry::global::ObjectSafeSpan;
 use opentelemetry::trace::TraceContextExt;
 use opentelemetry::trace::Tracer;
 use opentelemetry::Context;
 use spin_core::async_trait;
 use spin_core::wasmtime::component::Resource;
-use spin_world::wasi::clocks0_2_0::wall_clock::Datetime;
+use spin_world::wasi::clocks0_2_0::wall_clock;
+use spin_world::wasi::observe::traces::Datetime;
 use spin_world::wasi::observe::traces::{self, KeyValue, Span as WitSpan};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
@@ -97,12 +102,39 @@ impl traces::HostSpan for InstanceState {
 
     async fn add_event(
         &mut self,
-        _resource: Resource<WitSpan>,
-        _name: String,
-        _timestamp: Option<Datetime>,
-        _attributes: Option<Vec<KeyValue>>,
+        resource: Resource<WitSpan>,
+        name: String,
+        timestamp: Option<Datetime>,
+        attributes: Option<Vec<KeyValue>>,
     ) -> Result<()> {
-        todo!()
+        if let Some(guest_span) = self
+            .state
+            .write()
+            .unwrap()
+            .guest_spans
+            .get_mut(resource.rep())
+        {
+            let timestamp = if let Some(timestamp) = timestamp {
+                UNIX_EPOCH
+                    + Duration::from_secs(timestamp.seconds)
+                    + Duration::from_nanos(timestamp.nanoseconds as u64)
+            } else {
+                SystemTime::now()
+            };
+
+            let attributes = if let Some(attributes) = attributes {
+                attributes.into_iter().map(|a| a.into()).collect()
+            } else {
+                vec![]
+            };
+
+            guest_span
+                .inner
+                .add_event_with_timestamp(name.into(), timestamp, attributes)
+        } else {
+            tracing::debug!("can't find guest span to add events too")
+        }
+        Ok(())
     }
 
     async fn add_link(&mut self, _resource: Resource<WitSpan>, _link: traces::Link) -> Result<()> {

crates/factor-observe/src/host.rs

@@ -505,6 +505,83 @@ mod integration_tests {
         Ok(())
     }
 
+    #[tokio::test]
+    async fn wasi_observe_events() -> anyhow::Result<()> {
+        let collector = FakeCollectorServer::start()
+            .await
+            .expect("fake collector server should start");
+        let collector_endpoint = collector.endpoint().clone();
+
+        tokio::task::spawn_blocking(|| {
+            run_test_inited(
+                "wasi-observe-tracing",
+                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, "/events"),
+                        Response::new(200),
+                    )?;
+
+                    let mut spans: Vec<ExportedSpan>;
+                    assert_eventually!(
+                        {
+                            spans = collector.exported_spans();
+                            !spans.is_empty()
+                        },
+                        5
+                    );
+
+                    assert_eq!(spans.len(), 3);
+
+                    let event_span = spans
+                        .iter()
+                        .find(|s| s.name == "events")
+                        .expect("'events' span should exist");
+
+                    let events = event_span.events.clone();
+                    assert_eq!(events.len(), 3);
+
+                    let basic_event = events
+                        .iter()
+                        .find(|e| e.name == "basic-event")
+                        .expect("'basic' event should exist");
+                    let event_with_attributes = events
+                        .iter()
+                        .find(|e| e.name == "event-with-attributes")
+                        .expect("'event_with_attributes' event should exist");
+                    let event_with_timestamp = events
+                        .iter()
+                        .find(|e| e.name == "event-with-timestamp")
+                        .expect("'event_with_timestamp' event should exist");
+
+                    assert!(basic_event.time_unix_nano < event_with_attributes.time_unix_nano);
+                    assert_eq!(event_with_attributes.attributes.len(), 1);
+                    assert!(
+                        event_with_attributes.time_unix_nano < event_with_timestamp.time_unix_nano
+                    );
+
+                    Ok(())
+                },
+            )
+        })
+        .await??;
+
+        Ok(())
+    }
+
     // TODO: wasi_observe_set_event
     // TODO: wasi_observe_update_name
     // TODO: wasi_observe_set_link

tests/integration.rs

@@ -8,7 +8,10 @@ use spin_sdk::{
     http::{Method, Params, Request, Response, Router},
     http_component,
 };
-use wasi::observe::traces::{KeyValue, Span, SpanParent, Value};
+use wasi::{
+    clocks0_2_0::wall_clock::now,
+    observe::traces::{KeyValue, Span, SpanParent, Value},
+};
 
 #[http_component]
 fn handle(req: http::Request<()>) -> Response {
@@ -17,6 +20,7 @@ fn handle(req: http::Request<()>) -> Response {
     router.get("/drop-semantics", drop_semantics);
     router.get("/setting-attributes", setting_attributes);
     router.get_async("/host-guest-host", host_guest_host);
+    router.get("/events", events);
     router.handle(req)
 }
 
@@ -70,3 +74,21 @@ async fn host_guest_host(_req: Request, _params: Params) -> Response {
 
     Response::new(200, "")
 }
+
+fn events(_req: Request, _params: Params) -> Response {
+    let span = Span::start("events", &SpanParent::Implicit, None);
+    span.add_event("basic-event", None, None);
+    span.add_event(
+        "event-with-attributes",
+        None,
+        Some(&[KeyValue {
+            key: "foo".to_string(),
+            value: Value::Bool(true),
+        }]),
+    );
+    let mut now_plus = now();
+    now_plus.seconds += 1;
+    span.add_event("event-with-timestamp", Some(now_plus), None);
+    span.end(None);
+    Response::new(200, "")
+}