Switch from Fault to Blame

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

crates/factor-key-value/src/host.rs

@@ -2,7 +2,7 @@ use super::{Cas, SwapError};
 use anyhow::{Context, Result};
 use spin_core::{async_trait, wasmtime::component::Resource};
 use spin_resource_table::Table;
-use spin_telemetry::traces::{self, Fault};
+use spin_telemetry::traces::{self, Blame};
 use spin_world::v2::key_value;
 use spin_world::wasi::keyvalue as wasi_keyvalue;
 use std::{collections::HashSet, sync::Arc};
@@ -72,7 +72,7 @@ impl KeyValueDispatch {
     pub fn get_store<T: 'static>(&self, store: Resource<T>) -> anyhow::Result<&Arc<dyn Store>> {
         let res = self.stores.get(store.rep()).context("invalid store");
         if let Err(err) = &res {
-            traces::mark_as_error(err, Some(Fault::Host));
+            traces::mark_as_error(err, Some(Blame::Host));
         }
         res
     }
@@ -187,11 +187,11 @@ impl key_value::HostStore for KeyValueDispatch {
 
 /// Make sure that infrastructure related errors are tracked in the current span.
 fn track_error_on_span(err: Error) -> Error {
-    let fault = match err {
-        Error::NoSuchStore | Error::AccessDenied => Fault::Guest,
-        Error::StoreTableFull | Error::Other(_) => Fault::Host,
+    let blame = match err {
+        Error::NoSuchStore | Error::AccessDenied => Blame::Guest,
+        Error::StoreTableFull | Error::Other(_) => Blame::Host,
     };
-    traces::mark_as_error(&err, Some(fault));
+    traces::mark_as_error(&err, Some(blame));
     err
 }
 

crates/factor-variables/src/host.rs

@@ -1,5 +1,5 @@
 use spin_factors::anyhow;
-use spin_telemetry::traces::{self, Fault};
+use spin_telemetry::traces::{self, Blame};
 use spin_world::{v1, v2::variables, wasi::config as wasi_config};
 use tracing::instrument;
 
@@ -76,11 +76,11 @@ impl wasi_config::store::Host for InstanceState {
 /// Convert a `spin_expressions::Error` to a `variables::Error`, setting the current span's status and fault attribute.
 fn expressions_to_variables_err(err: spin_expressions::Error) -> variables::Error {
     use spin_expressions::Error;
-    let fault = match err {
-        Error::InvalidName(_) | Error::InvalidTemplate(_) | Error::Undefined(_) => Fault::Guest,
-        Error::Provider(_) => Fault::Host,
+    let blame = match err {
+        Error::InvalidName(_) | Error::InvalidTemplate(_) | Error::Undefined(_) => Blame::Guest,
+        Error::Provider(_) => Blame::Host,
     };
-    traces::mark_as_error(&err, Some(fault));
+    traces::mark_as_error(&err, Some(blame));
     match err {
         Error::InvalidName(msg) => variables::Error::InvalidName(msg),
         Error::Undefined(msg) => variables::Error::Undefined(msg),

crates/telemetry/src/traces.rs

@@ -67,27 +67,27 @@ pub(crate) fn otel_tracing_layer<S: Subscriber + for<'span> LookupSpan<'span>>(
 ///
 /// This can be used to filter errors in telemetry or logging systems.
 #[derive(Debug)]
-pub enum Fault {
+pub enum Blame {
     /// The error is most likely caused by the guest.
     Guest,
     /// The error might have been caused by the host.
     Host,
 }
 
-impl Fault {
+impl Blame {
     fn as_str(&self) -> &'static str {
         match self {
-            Fault::Guest => "guest",
-            Fault::Host => "host",
+            Blame::Guest => "guest",
+            Blame::Host => "host",
         }
     }
 }
 
-/// Marks the current span as an error with the given error message and optional fault type.
-pub fn mark_as_error<E: std::fmt::Display>(err: &E, fault: Option<Fault>) {
+/// Marks the current span as an error with the given error message and optional blame.
+pub fn mark_as_error<E: std::fmt::Display>(err: &E, blame: Option<Blame>) {
     let current_span = tracing::Span::current();
     current_span.set_status(opentelemetry::trace::Status::error(err.to_string()));
-    if let Some(fault) = fault {
-        current_span.set_attribute("error.fault", fault.as_str());
+    if let Some(blame) = blame {
+        current_span.set_attribute("error.blame", blame.as_str());
     }
 }