feat(factor-otel): small refactors

Signed-off-by: Andrew Steurer <[email protected]>

Author: asteurer

crates/factor-otel/Cargo.toml

@@ -22,4 +22,4 @@ tracing-opentelemetry = { workspace = true }
 toml = "0.5"
 
 [lints]
-workspace = true
+workspace = true

crates/factor-otel/src/host.rs

@@ -67,13 +67,20 @@ impl wasi::otel::metrics::Host for InstanceState {
             Ok(_) => Ok(Ok(())),
             Err(e) => match e {
                 OTelSdkError::AlreadyShutdown => {
-                    Ok(Err("Shutdown has already been invoked".to_string()))
+                    let msg = "Shutdown has already been invoked";
+                    tracing::error!(msg);
+                    Ok(Err(msg.to_string()))
+                }
+                OTelSdkError::InternalFailure(e) => {
+                    let detailed_msg = format!("Internal failure: {}", e);
+                    tracing::error!(detailed_msg);
+                    Ok(Err("Internal failure.".to_string()))
+                }
+                OTelSdkError::Timeout(d) => {
+                    let detailed_msg = format!("Operation timed out after {} seconds", d.as_secs());
+                    tracing::error!(detailed_msg);
+                    Ok(Err("Operation timed out.".to_string()))
                 }
-                OTelSdkError::InternalFailure(e) => Ok(Err("Internal failure: ".to_string() + &e)),
-                OTelSdkError::Timeout(d) => Ok(Err(format!(
-                    "Operation timed out after {} seconds",
-                    d.as_secs()
-                ))),
             },
         }
     }

crates/world/src/conversions.rs

@@ -561,29 +561,26 @@ mod otel {
     use std::borrow::Cow;
     use std::time::{Duration, SystemTime, UNIX_EPOCH};
     use wasi::clocks0_2_0::wall_clock;
-    use wasi::otel::metrics as wasi_metrics;
-    use wasi::otel::tracing as wasi_tracing;
-    use wasi::otel::types as wasi_types;
 
-    impl From<wasi_metrics::ResourceMetrics> for opentelemetry_sdk::metrics::data::ResourceMetrics {
-        fn from(value: wasi_metrics::ResourceMetrics) -> Self {
+    impl From<wasi::otel::metrics::ResourceMetrics>
+        for opentelemetry_sdk::metrics::data::ResourceMetrics
+    {
+        fn from(value: wasi::otel::metrics::ResourceMetrics) -> Self {
             Self {
                 resource: value.resource.into(),
                 scope_metrics: value.scope_metrics.into_iter().map(Into::into).collect(),
             }
         }
     }
 
-    impl From<wasi_metrics::Resource> for opentelemetry_sdk::Resource {
-        fn from(value: wasi_metrics::Resource) -> Self {
+    impl From<wasi::otel::metrics::Resource> for opentelemetry_sdk::Resource {
+        fn from(value: wasi::otel::metrics::Resource) -> Self {
             let attributes: Vec<opentelemetry::KeyValue> =
                 value.attributes.into_iter().map(Into::into).collect();
             let schema_url: Option<String> = value.schema_url.into();
 
             match schema_url {
                 Some(url) => opentelemetry_sdk::resource::Resource::builder()
-                    // TODO: I'm unclear about what to do with the `with_schema_url()` method and the
-                    // `with_attribute()` or `with_attributes()` methods. Is this good enough?
                     .with_schema_url(attributes, url)
                     .build(),
                 None => opentelemetry_sdk::resource::Resource::builder()
@@ -593,17 +590,17 @@ mod otel {
         }
     }
 
-    impl From<wasi_metrics::ScopeMetrics> for opentelemetry_sdk::metrics::data::ScopeMetrics {
-        fn from(value: wasi_metrics::ScopeMetrics) -> Self {
+    impl From<wasi::otel::metrics::ScopeMetrics> for opentelemetry_sdk::metrics::data::ScopeMetrics {
+        fn from(value: wasi::otel::metrics::ScopeMetrics) -> Self {
             Self {
                 scope: value.scope.into(),
                 metrics: value.metrics.into_iter().map(Into::into).collect(),
             }
         }
     }
 
-    impl From<wasi_metrics::Metric> for opentelemetry_sdk::metrics::data::Metric {
-        fn from(value: wasi_metrics::Metric) -> Self {
+    impl From<wasi::otel::metrics::Metric> for opentelemetry_sdk::metrics::data::Metric {
+        fn from(value: wasi::otel::metrics::Metric) -> Self {
             Self {
                 name: Cow::Owned(value.name),
                 description: Cow::Owned(value.description),
@@ -759,80 +756,84 @@ mod otel {
         };
     }
 
-    impl From<wasi_metrics::MetricData> for Box<dyn opentelemetry_sdk::metrics::data::Aggregation> {
-        fn from(value: wasi_metrics::MetricData) -> Self {
+    impl From<wasi::otel::metrics::MetricData>
+        for Box<dyn opentelemetry_sdk::metrics::data::Aggregation>
+    {
+        fn from(value: wasi::otel::metrics::MetricData) -> Self {
             match value {
-                wasi_metrics::MetricData::F64Sum(s) => wasi_sum_to_otel!(s, f64),
-                wasi_metrics::MetricData::S64Sum(s) => wasi_sum_to_otel!(s, i64),
-                wasi_metrics::MetricData::U64Sum(s) => wasi_sum_to_otel!(s, u64),
-                wasi_metrics::MetricData::F64Gauge(g) => wasi_gauge_to_otel!(g, f64),
-                wasi_metrics::MetricData::S64Gauge(g) => wasi_gauge_to_otel!(g, i64),
-                wasi_metrics::MetricData::U64Gauge(g) => wasi_gauge_to_otel!(g, u64),
-                wasi_metrics::MetricData::F64Histogram(h) => wasi_histogram_to_otel!(h, f64),
-                wasi_metrics::MetricData::S64Histogram(h) => wasi_histogram_to_otel!(h, i64),
-                wasi_metrics::MetricData::U64Histogram(h) => wasi_histogram_to_otel!(h, u64),
-                wasi_metrics::MetricData::F64ExponentialHistogram(h) => {
+                wasi::otel::metrics::MetricData::F64Sum(s) => wasi_sum_to_otel!(s, f64),
+                wasi::otel::metrics::MetricData::S64Sum(s) => wasi_sum_to_otel!(s, i64),
+                wasi::otel::metrics::MetricData::U64Sum(s) => wasi_sum_to_otel!(s, u64),
+                wasi::otel::metrics::MetricData::F64Gauge(g) => wasi_gauge_to_otel!(g, f64),
+                wasi::otel::metrics::MetricData::S64Gauge(g) => wasi_gauge_to_otel!(g, i64),
+                wasi::otel::metrics::MetricData::U64Gauge(g) => wasi_gauge_to_otel!(g, u64),
+                wasi::otel::metrics::MetricData::F64Histogram(h) => wasi_histogram_to_otel!(h, f64),
+                wasi::otel::metrics::MetricData::S64Histogram(h) => wasi_histogram_to_otel!(h, i64),
+                wasi::otel::metrics::MetricData::U64Histogram(h) => wasi_histogram_to_otel!(h, u64),
+                wasi::otel::metrics::MetricData::F64ExponentialHistogram(h) => {
                     wasi_exponential_histogram_to_otel!(h, f64)
                 }
-                wasi_metrics::MetricData::S64ExponentialHistogram(h) => {
+                wasi::otel::metrics::MetricData::S64ExponentialHistogram(h) => {
                     wasi_exponential_histogram_to_otel!(h, i64)
                 }
-                wasi_metrics::MetricData::U64ExponentialHistogram(h) => {
+                wasi::otel::metrics::MetricData::U64ExponentialHistogram(h) => {
                     wasi_exponential_histogram_to_otel!(h, u64)
                 }
             }
         }
     }
 
-    impl From<wasi_metrics::MetricNumber> for f64 {
-        fn from(value: wasi_metrics::MetricNumber) -> Self {
+    impl From<wasi::otel::metrics::MetricNumber> for f64 {
+        fn from(value: wasi::otel::metrics::MetricNumber) -> Self {
             match value {
-                wasi_metrics::MetricNumber::F64(n) => n,
+                wasi::otel::metrics::MetricNumber::F64(n) => n,
                 _ => panic!("error converting WASI MetricNumber to f64"),
             }
         }
     }
 
-    impl From<wasi_metrics::MetricNumber> for u64 {
-        fn from(value: wasi_metrics::MetricNumber) -> Self {
+    impl From<wasi::otel::metrics::MetricNumber> for u64 {
+        fn from(value: wasi::otel::metrics::MetricNumber) -> Self {
             match value {
-                wasi_metrics::MetricNumber::U64(n) => n,
+                wasi::otel::metrics::MetricNumber::U64(n) => n,
                 _ => panic!("error converting WASI MetricNumber to u64"),
             }
         }
     }
 
-    impl From<wasi_metrics::MetricNumber> for i64 {
-        fn from(value: wasi_metrics::MetricNumber) -> Self {
+    impl From<wasi::otel::metrics::MetricNumber> for i64 {
+        fn from(value: wasi::otel::metrics::MetricNumber) -> Self {
             match value {
-                wasi_metrics::MetricNumber::S64(n) => n,
+                wasi::otel::metrics::MetricNumber::S64(n) => n,
                 _ => panic!("error converting WASI MetricNumber to i64"),
             }
         }
     }
 
-    impl From<wasi_metrics::ExponentialBucket> for opentelemetry_sdk::metrics::data::ExponentialBucket {
-        fn from(value: wasi_metrics::ExponentialBucket) -> Self {
+    impl From<wasi::otel::metrics::ExponentialBucket>
+        for opentelemetry_sdk::metrics::data::ExponentialBucket
+    {
+        fn from(value: wasi::otel::metrics::ExponentialBucket) -> Self {
             Self {
                 offset: value.offset,
                 counts: value.counts,
             }
         }
     }
 
-    impl From<wasi_metrics::Temporality> for opentelemetry_sdk::metrics::Temporality {
-        fn from(value: wasi_metrics::Temporality) -> Self {
+    impl From<wasi::otel::metrics::Temporality> for opentelemetry_sdk::metrics::Temporality {
+        fn from(value: wasi::otel::metrics::Temporality) -> Self {
             use opentelemetry_sdk::metrics::Temporality;
             match value {
-                wasi_metrics::Temporality::Cumulative => Temporality::Cumulative,
-                wasi_metrics::Temporality::Delta => Temporality::Delta,
-                wasi_metrics::Temporality::LowMemory => Temporality::LowMemory,
+                wasi::otel::metrics::Temporality::Cumulative => Temporality::Cumulative,
+                wasi::otel::metrics::Temporality::Delta => Temporality::Delta,
+                wasi::otel::metrics::Temporality::LowMemory => Temporality::LowMemory,
             }
         }
     }
 
-    impl From<wasi_tracing::SpanData> for opentelemetry_sdk::trace::SpanData {
-        fn from(value: wasi_tracing::SpanData) -> Self {
+    impl From<wasi::otel::tracing::SpanData> for opentelemetry_sdk::trace::SpanData {
+        fn from(value: wasi::otel::tracing::SpanData) -> Self {
             let mut span_events = SpanEvents::default();
             span_events.events = value.events.into_iter().map(Into::into).collect();
             span_events.dropped_count = value.dropped_events;
@@ -857,8 +858,8 @@ mod otel {
         }
     }
 
-    impl From<wasi_tracing::SpanContext> for opentelemetry::trace::SpanContext {
-        fn from(sc: wasi_tracing::SpanContext) -> Self {
+    impl From<wasi::otel::tracing::SpanContext> for opentelemetry::trace::SpanContext {
+        fn from(sc: wasi::otel::tracing::SpanContext) -> Self {
             let trace_id = opentelemetry::trace::TraceId::from_hex(&sc.trace_id)
                 .unwrap_or(opentelemetry::trace::TraceId::INVALID);
             let span_id = opentelemetry::trace::SpanId::from_hex(&sc.span_id)
@@ -875,7 +876,7 @@ mod otel {
         }
     }
 
-    impl From<opentelemetry::trace::SpanContext> for wasi_tracing::SpanContext {
+    impl From<opentelemetry::trace::SpanContext> for wasi::otel::tracing::SpanContext {
         fn from(sc: opentelemetry::trace::SpanContext) -> Self {
             Self {
                 trace_id: format!("{:x}", sc.trace_id()),
@@ -898,68 +899,68 @@ mod otel {
         }
     }
 
-    impl From<wasi_tracing::TraceFlags> for opentelemetry::trace::TraceFlags {
-        fn from(flags: wasi_tracing::TraceFlags) -> Self {
+    impl From<wasi::otel::tracing::TraceFlags> for opentelemetry::trace::TraceFlags {
+        fn from(flags: wasi::otel::tracing::TraceFlags) -> Self {
             Self::new(flags.as_array()[0] as u8)
         }
     }
 
-    impl From<opentelemetry::trace::TraceFlags> for wasi_tracing::TraceFlags {
+    impl From<opentelemetry::trace::TraceFlags> for wasi::otel::tracing::TraceFlags {
         fn from(flags: opentelemetry::trace::TraceFlags) -> Self {
             if flags.is_sampled() {
-                wasi_tracing::TraceFlags::SAMPLED
+                wasi::otel::tracing::TraceFlags::SAMPLED
             } else {
-                wasi_tracing::TraceFlags::empty()
+                wasi::otel::tracing::TraceFlags::empty()
             }
         }
     }
 
-    impl From<wasi_tracing::SpanKind> for opentelemetry::trace::SpanKind {
-        fn from(kind: wasi_tracing::SpanKind) -> Self {
+    impl From<wasi::otel::tracing::SpanKind> for opentelemetry::trace::SpanKind {
+        fn from(kind: wasi::otel::tracing::SpanKind) -> Self {
             match kind {
-                wasi_tracing::SpanKind::Client => opentelemetry::trace::SpanKind::Client,
-                wasi_tracing::SpanKind::Server => opentelemetry::trace::SpanKind::Server,
-                wasi_tracing::SpanKind::Producer => opentelemetry::trace::SpanKind::Producer,
-                wasi_tracing::SpanKind::Consumer => opentelemetry::trace::SpanKind::Consumer,
-                wasi_tracing::SpanKind::Internal => opentelemetry::trace::SpanKind::Internal,
+                wasi::otel::tracing::SpanKind::Client => opentelemetry::trace::SpanKind::Client,
+                wasi::otel::tracing::SpanKind::Server => opentelemetry::trace::SpanKind::Server,
+                wasi::otel::tracing::SpanKind::Producer => opentelemetry::trace::SpanKind::Producer,
+                wasi::otel::tracing::SpanKind::Consumer => opentelemetry::trace::SpanKind::Consumer,
+                wasi::otel::tracing::SpanKind::Internal => opentelemetry::trace::SpanKind::Internal,
             }
         }
     }
 
-    impl From<wasi_tracing::KeyValue> for opentelemetry::KeyValue {
-        fn from(kv: wasi_tracing::KeyValue) -> Self {
+    impl From<wasi::otel::tracing::KeyValue> for opentelemetry::KeyValue {
+        fn from(kv: wasi::otel::tracing::KeyValue) -> Self {
             opentelemetry::KeyValue::new(kv.key, kv.value)
         }
     }
 
-    impl From<&wasi_tracing::KeyValue> for opentelemetry::KeyValue {
-        fn from(kv: &wasi_tracing::KeyValue) -> Self {
+    impl From<&wasi::otel::tracing::KeyValue> for opentelemetry::KeyValue {
+        fn from(kv: &wasi::otel::tracing::KeyValue) -> Self {
             opentelemetry::KeyValue::new(kv.key.to_owned(), kv.value.to_owned())
         }
     }
 
-    impl From<wasi_types::Value> for opentelemetry::Value {
-        fn from(value: wasi_types::Value) -> Self {
+    impl From<wasi::otel::types::Value> for opentelemetry::Value {
+        fn from(value: wasi::otel::types::Value) -> Self {
             match value {
-                wasi_types::Value::String(v) => v.into(),
-                wasi_types::Value::Bool(v) => v.into(),
-                wasi_types::Value::F64(v) => v.into(),
-                wasi_types::Value::S64(v) => v.into(),
-                wasi_types::Value::StringArray(v) => opentelemetry::Value::Array(
+                wasi::otel::types::Value::String(v) => v.into(),
+                wasi::otel::types::Value::Bool(v) => v.into(),
+                wasi::otel::types::Value::F64(v) => v.into(),
+                wasi::otel::types::Value::S64(v) => v.into(),
+                wasi::otel::types::Value::StringArray(v) => opentelemetry::Value::Array(
                     v.into_iter()
                         .map(StringValue::from)
                         .collect::<Vec<_>>()
                         .into(),
                 ),
-                wasi_types::Value::BoolArray(v) => opentelemetry::Value::Array(v.into()),
-                wasi_types::Value::F64Array(v) => opentelemetry::Value::Array(v.into()),
-                wasi_types::Value::S64Array(v) => opentelemetry::Value::Array(v.into()),
+                wasi::otel::types::Value::BoolArray(v) => opentelemetry::Value::Array(v.into()),
+                wasi::otel::types::Value::F64Array(v) => opentelemetry::Value::Array(v.into()),
+                wasi::otel::types::Value::S64Array(v) => opentelemetry::Value::Array(v.into()),
             }
         }
     }
 
-    impl From<wasi_tracing::Event> for opentelemetry::trace::Event {
-        fn from(event: wasi_tracing::Event) -> Self {
+    impl From<wasi::otel::tracing::Event> for opentelemetry::trace::Event {
+        fn from(event: wasi::otel::tracing::Event) -> Self {
             Self::new(
                 event.name,
                 event.time.into(),
@@ -969,8 +970,8 @@ mod otel {
         }
     }
 
-    impl From<wasi_tracing::Link> for opentelemetry::trace::Link {
-        fn from(link: wasi_tracing::Link) -> Self {
+    impl From<wasi::otel::tracing::Link> for opentelemetry::trace::Link {
+        fn from(link: wasi::otel::tracing::Link) -> Self {
             Self::new(
                 link.span_context.into(),
                 link.attributes.into_iter().map(Into::into).collect(),
@@ -979,20 +980,20 @@ mod otel {
         }
     }
 
-    impl From<wasi_tracing::Status> for opentelemetry::trace::Status {
-        fn from(status: wasi_tracing::Status) -> Self {
+    impl From<wasi::otel::tracing::Status> for opentelemetry::trace::Status {
+        fn from(status: wasi::otel::tracing::Status) -> Self {
             match status {
-                wasi_tracing::Status::Unset => Self::Unset,
-                wasi_tracing::Status::Ok => Self::Ok,
-                wasi_tracing::Status::Error(s) => Self::Error {
+                wasi::otel::tracing::Status::Unset => Self::Unset,
+                wasi::otel::tracing::Status::Ok => Self::Ok,
+                wasi::otel::tracing::Status::Error(s) => Self::Error {
                     description: s.into(),
                 },
             }
         }
     }
 
-    impl From<wasi_types::InstrumentationScope> for opentelemetry::InstrumentationScope {
-        fn from(value: wasi_tracing::InstrumentationScope) -> Self {
+    impl From<wasi::otel::types::InstrumentationScope> for opentelemetry::InstrumentationScope {
+        fn from(value: wasi::otel::tracing::InstrumentationScope) -> Self {
             let builder = Self::builder(value.name)
                 .with_attributes(value.attributes.into_iter().map(Into::into));
             match (value.version, value.schema_url) {