Namespacing and wit update

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

Author: calebschoepp

crates/factor-observe/src/host.rs

@@ -9,26 +9,22 @@ use opentelemetry::trace::Tracer;
 use opentelemetry::Context;
 use spin_core::async_trait;
 use spin_core::wasmtime::component::Resource;
-use spin_world::wasi::observe::traces::Datetime;
-use spin_world::wasi::observe::traces::{self, KeyValue, Span as WitSpan};
+use spin_world::wasi::observe::traces;
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 use crate::{GuestSpan, InstanceState};
 
 #[async_trait]
 impl traces::Host for InstanceState {}
 
-// TODO: Figure out a standard import scheme for my wit types vs otel types
-
 #[async_trait]
 impl traces::HostSpan for InstanceState {
     // TODO(Caleb): Make this implicit logic make more sense (the indexmap seems wrong)
     async fn start(
         &mut self,
         name: String,
-        _parent: traces::SpanParent,
         _options: Option<traces::StartOptions>,
-    ) -> Result<Resource<WitSpan>> {
+    ) -> Result<Resource<traces::Span>> {
         let mut state = self.state.write().unwrap();
 
         if state.active_spans.is_empty() {
@@ -70,11 +66,14 @@ impl traces::HostSpan for InstanceState {
         Ok(Resource::new_own(resource_id))
     }
 
-    async fn span_context(&mut self, _resource: Resource<WitSpan>) -> Result<traces::SpanContext> {
+    async fn span_context(
+        &mut self,
+        _resource: Resource<traces::Span>,
+    ) -> Result<traces::SpanContext> {
         todo!()
     }
 
-    async fn is_recording(&mut self, resource: Resource<WitSpan>) -> Result<bool> {
+    async fn is_recording(&mut self, resource: Resource<traces::Span>) -> Result<bool> {
         if let Some(guest_span) = self.state.read().unwrap().guest_spans.get(resource.rep()) {
             Ok(guest_span.inner.is_recording())
         } else {
@@ -85,8 +84,8 @@ impl traces::HostSpan for InstanceState {
 
     async fn set_attributes(
         &mut self,
-        resource: Resource<WitSpan>,
-        attributes: Vec<KeyValue>,
+        resource: Resource<traces::Span>,
+        attributes: Vec<traces::KeyValue>,
     ) -> Result<()> {
         if let Some(guest_span) = self
             .state
@@ -106,10 +105,10 @@ impl traces::HostSpan for InstanceState {
 
     async fn add_event(
         &mut self,
-        resource: Resource<WitSpan>,
+        resource: Resource<traces::Span>,
         name: String,
-        timestamp: Option<Datetime>,
-        attributes: Option<Vec<KeyValue>>,
+        timestamp: Option<traces::Datetime>,
+        attributes: Option<Vec<traces::KeyValue>>,
     ) -> Result<()> {
         if let Some(guest_span) = self
             .state
@@ -141,19 +140,23 @@ impl traces::HostSpan for InstanceState {
         Ok(())
     }
 
-    async fn add_link(&mut self, _resource: Resource<WitSpan>, _link: traces::Link) -> Result<()> {
+    async fn add_link(
+        &mut self,
+        _resource: Resource<traces::Span>,
+        _link: traces::Link,
+    ) -> Result<()> {
         todo!()
     }
 
     async fn set_status(
         &mut self,
-        _resource: Resource<WitSpan>,
+        _resource: Resource<traces::Span>,
         _status: traces::Status,
     ) -> Result<()> {
         todo!()
     }
 
-    async fn update_name(&mut self, resource: Resource<WitSpan>, name: String) -> Result<()> {
+    async fn update_name(&mut self, resource: Resource<traces::Span>, name: String) -> Result<()> {
         if let Some(guest_span) = self
             .state
             .write()
@@ -170,8 +173,8 @@ impl traces::HostSpan for InstanceState {
 
     async fn end(
         &mut self,
-        resource: Resource<WitSpan>,
-        _timestamp: Option<Datetime>,
+        resource: Resource<traces::Span>,
+        _timestamp: Option<traces::Datetime>,
     ) -> Result<()> {
         if let Some(guest_span) = self
             .state
@@ -187,7 +190,7 @@ impl traces::HostSpan for InstanceState {
         Ok(())
     }
 
-    fn drop(&mut self, _resource: Resource<WitSpan>) -> Result<()> {
+    fn drop(&mut self, _resource: Resource<traces::Span>) -> Result<()> {
         // TODO(Caleb): What do we want the dropping behavior to be?
         // TODO(Caleb): How is the drop semantics test passing?
         Ok(())

crates/world/src/conversions.rs

@@ -220,34 +220,32 @@ mod llm {
 }
 
 mod observe {
-    use opentelemetry::StringValue;
-
     use super::*;
+    use opentelemetry::StringValue;
+    use wasi::observe::traces;
 
-    impl From<wasi::observe::traces::Value> for opentelemetry::Value {
-        fn from(value: wasi::observe::traces::Value) -> Self {
+    impl From<traces::Value> for opentelemetry::Value {
+        fn from(value: traces::Value) -> Self {
             match value {
-                wasi::observe::traces::Value::String(v) => v.into(),
-                wasi::observe::traces::Value::Bool(v) => v.into(),
-                wasi::observe::traces::Value::Float64(v) => v.into(),
-                wasi::observe::traces::Value::S64(v) => v.into(),
-                wasi::observe::traces::Value::StringArray(v) => opentelemetry::Value::Array(
+                traces::Value::String(v) => v.into(),
+                traces::Value::Bool(v) => v.into(),
+                traces::Value::Float64(v) => v.into(),
+                traces::Value::S64(v) => v.into(),
+                traces::Value::StringArray(v) => opentelemetry::Value::Array(
                     v.into_iter()
                         .map(StringValue::from)
                         .collect::<Vec<_>>()
                         .into(),
                 ),
-                wasi::observe::traces::Value::BoolArray(v) => opentelemetry::Value::Array(v.into()),
-                wasi::observe::traces::Value::Float64Array(v) => {
-                    opentelemetry::Value::Array(v.into())
-                }
-                wasi::observe::traces::Value::S64Array(v) => opentelemetry::Value::Array(v.into()),
+                traces::Value::BoolArray(v) => opentelemetry::Value::Array(v.into()),
+                traces::Value::Float64Array(v) => opentelemetry::Value::Array(v.into()),
+                traces::Value::S64Array(v) => opentelemetry::Value::Array(v.into()),
             }
         }
     }
 
-    impl From<wasi::observe::traces::KeyValue> for opentelemetry::KeyValue {
-        fn from(kv: wasi::observe::traces::KeyValue) -> Self {
+    impl From<traces::KeyValue> for opentelemetry::KeyValue {
+        fn from(kv: traces::KeyValue) -> Self {
             opentelemetry::KeyValue::new(kv.key, kv.value)
         }
     }

tests/test-components/components/wasi-observe-tracing/src/lib.rs

@@ -25,25 +25,25 @@ fn handle(req: http::Request<()>) -> Response {
 }
 
 fn nested_spans(_req: Request, _params: Params) -> Response {
-    let span = Span::start("outer_func", &SpanParent::Implicit, None);
+    let span = Span::start("outer_func", None);
     inner_func();
     span.end(None);
     Response::new(200, "")
 }
 
 fn inner_func() {
-    let span = Span::start("inner_func", &SpanParent::Implicit, None);
+    let span = Span::start("inner_func", None);
     span.end(None);
 }
 
 fn drop_semantics(_req: Request, _params: Params) -> Response {
-    let _span = Span::start("drop_semantics", &SpanParent::Implicit, None);
+    let _span = Span::start("drop_semantics", None);
     Response::new(200, "")
     // _span will drop here and should be ended
 }
 
 fn setting_attributes(_req: Request, _params: Params) -> Response {
-    let span = Span::start("setting_attributes", &SpanParent::Implicit, None);
+    let span = Span::start("setting_attributes", None);
     span.set_attributes(&[KeyValue {
         key: "foo".to_string(),
         value: Value::String("bar".to_string()),
@@ -63,7 +63,7 @@ fn setting_attributes(_req: Request, _params: Params) -> Response {
 }
 
 async fn host_guest_host(_req: Request, _params: Params) -> Response {
-    let span = Span::start("guest", &SpanParent::Implicit, None);
+    let span = Span::start("guest", None);
 
     let req = Request::builder()
         .method(Method::Get)
@@ -76,7 +76,7 @@ async fn host_guest_host(_req: Request, _params: Params) -> Response {
 }
 
 fn events(_req: Request, _params: Params) -> Response {
-    let span = Span::start("events", &SpanParent::Implicit, None);
+    let span = Span::start("events", None);
     span.add_event("basic-event", None, None);
     span.add_event(
         "event-with-attributes",

wit/deps/observe/traces.wit

@@ -3,8 +3,8 @@ interface traces {
 
     /// Represents a unit of work or operation.
     resource span {
-        /// Starts a new span with the given name, parent, and options.
-        start: static func(name: string, parent: span-parent, options: option<start-options>) -> span;
+        /// Starts a new span with the given name and options.
+        start: static func(name: string, options: option<start-options>) -> span;
 
         /// Get the `span-context` for this `span`.
         span-context: func() -> span-context;
@@ -39,6 +39,8 @@ interface traces {
 
     /// Configuration for starting a `span`.
     record start-options {
+        /// Parent for the new `span`. If this is not defined it defaults to implicit.
+        parent: option<span-parent>,
         /// `span-kind` for the new `span`.
         span-kind: option<span-kind>,
         /// Attributes for the new `span`.