diff --git a/Cargo.lock b/Cargo.lock
index b94bde3868..a1cf2a5136 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9231,6 +9231,7 @@ dependencies = [
  "spin-factors-test",
  "spin-locked-app",
  "spin-resource-table",
+ "spin-telemetry",
  "spin-wasi-async",
  "spin-world",
  "tokio",
diff --git a/crates/factor-outbound-mqtt/src/host.rs b/crates/factor-outbound-mqtt/src/host.rs
index 5a090f3772..63d2932a90 100644
--- a/crates/factor-outbound-mqtt/src/host.rs
+++ b/crates/factor-outbound-mqtt/src/host.rs
@@ -163,8 +163,12 @@ impl v3::HostConnectionWithStore for crate::MqttFactorData {
     }
 
     #[instrument(name = "spin_outbound_mqtt.publish", skip(accessor, connection, payload), err(level = Level::INFO),
-        fields(otel.kind = "producer", otel.name = format!("{} publish", topic), messaging.operation = "publish",
-        messaging.system = "mqtt"))]
+        fields(
+            otel.kind = "producer",
+            messaging.operation = "publish",
+            messaging.system = "mqtt",
+            messaging.destination.name = topic,
+        ))]
     async fn publish<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -236,8 +240,12 @@ impl v2::HostConnection for InstanceState {
     /// current trace context into the payload yourself.
     /// https://w3c.github.io/trace-context-mqtt/#mqtt-v3-recommendation.
     #[instrument(name = "spin_outbound_mqtt.publish", skip(self, connection, payload), err(level = Level::INFO),
-        fields(otel.kind = "producer", otel.name = format!("{} publish", topic), messaging.operation = "publish",
-        messaging.system = "mqtt"))]
+        fields(
+            otel.kind = "producer",
+            messaging.operation = "publish",
+            messaging.system = "mqtt",
+            messaging.destination.name = topic,
+        ))]
     async fn publish(
         &mut self,
         connection: Resource<v2::Connection>,
diff --git a/crates/factor-outbound-mysql/src/host.rs b/crates/factor-outbound-mysql/src/host.rs
index 0e3fdf512c..79d94186bb 100644
--- a/crates/factor-outbound-mysql/src/host.rs
+++ b/crates/factor-outbound-mysql/src/host.rs
@@ -178,7 +178,8 @@ impl<C: Client> v3::HostConnectionWithStore for MysqlFactorData<C> {
 impl<C: Client> v2::Host for InstanceState<C> {}
 
 impl<C: Client> v2::HostConnection for InstanceState<C> {
-    #[instrument(name = "spin_outbound_mysql.open", skip(self, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "mysql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_mysql.open", skip(self, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "mysql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open(&mut self, address: String) -> Result<Resource<v2::Connection>, v2::Error> {
         let permit = self
             .semaphore
@@ -193,7 +194,8 @@ impl<C: Client> v2::HostConnection for InstanceState<C> {
             .map(Resource::new_own)
     }
 
-    #[instrument(name = "spin_outbound_mysql.execute", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "mysql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_mysql.execute", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "mysql"))]
     async fn execute(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -211,7 +213,8 @@ impl<C: Client> v2::HostConnection for InstanceState<C> {
             .map_err(track_db_error_on_span)
     }
 
-    #[instrument(name = "spin_outbound_mysql.query", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "mysql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_mysql.query", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "mysql"))]
     async fn query(
         &mut self,
         connection: Resource<v2::Connection>,
diff --git a/crates/factor-outbound-pg/src/host.rs b/crates/factor-outbound-pg/src/host.rs
index 34b66249f0..09f1951f80 100644
--- a/crates/factor-outbound-pg/src/host.rs
+++ b/crates/factor-outbound-pg/src/host.rs
@@ -92,7 +92,8 @@ fn v3_params_to_v4(params: Vec<v3::ParameterValue>) -> Vec<v4::ParameterValue> {
 }
 
 impl<CF: ClientFactory> v3::HostConnection for InstanceState<CF> {
-    #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open(&mut self, address: String) -> Result<Resource<v3::Connection>, v3::Error> {
         spin_factor_outbound_networking::record_address_fields(&address);
 
@@ -106,7 +107,8 @@ impl<CF: ClientFactory> v3::HostConnection for InstanceState<CF> {
             .map_err(v3::Error::from)
     }
 
-    #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn execute(
         &mut self,
         connection: Resource<v3::Connection>,
@@ -122,7 +124,8 @@ impl<CF: ClientFactory> v3::HostConnection for InstanceState<CF> {
             .map_err(track_db_error_on_span_v3)
     }
 
-    #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn query(
         &mut self,
         connection: Resource<v3::Connection>,
@@ -199,7 +202,8 @@ impl<CF: ClientFactory> v4::HostConnectionBuilder for InstanceState<CF> {
 }
 
 impl<CF: ClientFactory> v4::HostConnection for InstanceState<CF> {
-    #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open(&mut self, address: String) -> Result<Resource<v4::Connection>, v4::Error> {
         spin_factor_outbound_networking::record_address_fields(&address);
 
@@ -210,7 +214,8 @@ impl<CF: ClientFactory> v4::HostConnection for InstanceState<CF> {
         self.open_connection(&address, None).await
     }
 
-    #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn execute(
         &mut self,
         connection: Resource<v4::Connection>,
@@ -224,7 +229,8 @@ impl<CF: ClientFactory> v4::HostConnection for InstanceState<CF> {
             .map_err(track_db_error_on_span_v4)
     }
 
-    #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn query(
         &mut self,
         connection: Resource<v4::Connection>,
@@ -247,7 +253,8 @@ impl<CF: ClientFactory> v4::HostConnection for InstanceState<CF> {
 impl<CF: ClientFactory> spin_world::spin::postgres4_2_0::postgres::HostConnectionWithStore
     for crate::PgFactorData<CF>
 {
-    #[instrument(name = "spin_outbound_pg.open_async", skip(accessor, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_pg.open_async", skip(accessor, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open_async<T>(
         accessor: &Accessor<T, Self>,
         address: String,
@@ -260,7 +267,8 @@ impl<CF: ClientFactory> spin_world::spin::postgres4_2_0::postgres::HostConnectio
         Self::open_connection_async(accessor, &address, None).await
     }
 
-    #[instrument(name = "spin_outbound_pg.execute", skip(accessor, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.execute", skip(accessor, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn execute_async<T>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v4::Connection>,
@@ -282,7 +290,8 @@ impl<CF: ClientFactory> spin_world::spin::postgres4_2_0::postgres::HostConnectio
     }
 
     #[allow(clippy::type_complexity)] // blame bindgen, clippy, blame bindgen
-    #[instrument(name = "spin_outbound_pg.query_async", skip(accessor, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.query_async", skip(accessor, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn query_async<T>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v4::Connection>,
@@ -472,7 +481,8 @@ macro_rules! delegate {
 impl<CF: ClientFactory> v2::Host for InstanceState<CF> {}
 
 impl<CF: ClientFactory> v2::HostConnection for InstanceState<CF> {
-    #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open(&mut self, address: String) -> Result<Resource<v2::Connection>, v2::Error> {
         self.otel.reparent_tracing_span();
         spin_factor_outbound_networking::record_address_fields(&address);
@@ -486,7 +496,8 @@ impl<CF: ClientFactory> v2::HostConnection for InstanceState<CF> {
             .map_err(v2::Error::from)
     }
 
-    #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn execute(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -506,7 +517,8 @@ impl<CF: ClientFactory> v2::HostConnection for InstanceState<CF> {
             .map_err(track_db_error_on_span_v2)
     }
 
-    #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql", otel.name = statement))]
+    #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "postgresql"))]
     async fn query(
         &mut self,
         connection: Resource<v2::Connection>,
diff --git a/crates/factor-outbound-redis/src/host.rs b/crates/factor-outbound-redis/src/host.rs
index f349cf1992..6414a8e922 100644
--- a/crates/factor-outbound-redis/src/host.rs
+++ b/crates/factor-outbound-redis/src/host.rs
@@ -236,7 +236,8 @@ impl crate::RedisFactorData {
 }
 
 impl v3::HostConnectionWithStore for crate::RedisFactorData {
-    #[instrument(name = "spin_outbound_redis.open_connection", skip(accessor, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_redis.open_connection", skip(accessor, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open<T: Send>(
         accessor: &Accessor<T, Self>,
         address: String,
@@ -281,7 +282,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         })
     }
 
-    #[instrument(name = "spin_outbound_redis.publish", skip(accessor, connection, payload), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("PUBLISH {}", channel)))]
+    #[instrument(name = "spin_outbound_redis.publish", skip(accessor, connection, payload), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "PUBLISH"))]
     async fn publish<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -292,7 +294,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::publish(&mut conn, channel, payload).await
     }
 
-    #[instrument(name = "spin_outbound_redis.get", skip(accessor, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("GET {}", key)))]
+    #[instrument(name = "spin_outbound_redis.get", skip(accessor, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "GET"))]
     async fn get<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -302,7 +305,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::get(&mut conn, key).await
     }
 
-    #[instrument(name = "spin_outbound_redis.set", skip(accessor, connection, value), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SET {}", key)))]
+    #[instrument(name = "spin_outbound_redis.set", skip(accessor, connection, value), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SET"))]
     async fn set<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -313,7 +317,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::set(&mut conn, key, value).await
     }
 
-    #[instrument(name = "spin_outbound_redis.incr", skip(accessor, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("INCRBY {} 1", key)))]
+    #[instrument(name = "spin_outbound_redis.incr", skip(accessor, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "INCRBY"))]
     async fn incr<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -323,7 +328,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::incr(&mut conn, key).await
     }
 
-    #[instrument(name = "spin_outbound_redis.del", skip(accessor, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("DEL {}", keys.join(" "))))]
+    #[instrument(name = "spin_outbound_redis.del", skip(accessor, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "DEL"))]
     async fn del<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -333,7 +339,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::del(&mut conn, keys).await
     }
 
-    #[instrument(name = "spin_outbound_redis.sadd", skip(accessor, connection, values), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SADD {} {}", key, values.join(" "))))]
+    #[instrument(name = "spin_outbound_redis.sadd", skip(accessor, connection, values), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SADD"))]
     async fn sadd<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -344,7 +351,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::sadd(&mut conn, key, values).await
     }
 
-    #[instrument(name = "spin_outbound_redis.smembers", skip(accessor, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SMEMBERS {}", key)))]
+    #[instrument(name = "spin_outbound_redis.smembers", skip(accessor, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SMEMBERS"))]
     async fn smembers<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -354,7 +362,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::smembers(&mut conn, key).await
     }
 
-    #[instrument(name = "spin_outbound_redis.srem", skip(accessor, connection, values), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SREM {} {}", key, values.join(" "))))]
+    #[instrument(name = "spin_outbound_redis.srem", skip(accessor, connection, values), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SREM"))]
     async fn srem<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -365,7 +374,8 @@ impl v3::HostConnectionWithStore for crate::RedisFactorData {
         operations::srem(&mut conn, key, values).await
     }
 
-    #[instrument(name = "spin_outbound_redis.execute", skip(accessor, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("{}", command)))]
+    #[instrument(name = "spin_outbound_redis.execute", skip(accessor, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("{}", command)))]
     async fn execute<T: Send>(
         accessor: &Accessor<T, Self>,
         connection: Resource<v3::Connection>,
@@ -386,7 +396,8 @@ impl v2::Host for crate::InstanceState {
 }
 
 impl v2::HostConnection for crate::InstanceState {
-    #[instrument(name = "spin_outbound_redis.open_connection", skip(self, address), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
+    #[instrument(name = "spin_outbound_redis.open_connection", skip(self, address), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", {otel_attribute::SERVER_ADDRESS} = Empty, {otel_attribute::SERVER_PORT} = Empty, {otel_attribute::DB_NAMESPACE} = Empty))]
     async fn open(&mut self, address: String) -> Result<Resource<v2::Connection>, v2::Error> {
         self.otel.reparent_tracing_span();
         if !self
@@ -400,7 +411,8 @@ impl v2::HostConnection for crate::InstanceState {
         self.establish_connection(address).await
     }
 
-    #[instrument(name = "spin_outbound_redis.publish", skip(self, connection, payload), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("PUBLISH {}", channel)))]
+    #[instrument(name = "spin_outbound_redis.publish", skip(self, connection, payload), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "PUBLISH"))]
     async fn publish(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -414,7 +426,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::publish(conn, channel, payload).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.get", skip(self, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("GET {}", key)))]
+    #[instrument(name = "spin_outbound_redis.get", skip(self, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "GET"))]
     async fn get(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -427,7 +440,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::get(conn, key).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.set", skip(self, connection, value), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SET {}", key)))]
+    #[instrument(name = "spin_outbound_redis.set", skip(self, connection, value), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SET"))]
     async fn set(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -440,7 +454,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::set(conn, key, value).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.incr", skip(self, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("INCRBY {} 1", key)))]
+    #[instrument(name = "spin_outbound_redis.incr", skip(self, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "INCRBY"))]
     async fn incr(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -452,7 +467,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::incr(conn, key).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.del", skip(self, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("DEL {}", keys.join(" "))))]
+    #[instrument(name = "spin_outbound_redis.del", skip(self, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "DEL"))]
     async fn del(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -464,7 +480,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::del(conn, keys).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.sadd", skip(self, connection, values), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SADD {} {}", key, values.join(" "))))]
+    #[instrument(name = "spin_outbound_redis.sadd", skip(self, connection, values), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SADD"))]
     async fn sadd(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -477,7 +494,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::sadd(conn, key, values).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.smembers", skip(self, connection), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SMEMBERS {}", key)))]
+    #[instrument(name = "spin_outbound_redis.smembers", skip(self, connection), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SMEMBERS"))]
     async fn smembers(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -489,7 +507,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::smembers(conn, key).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.srem", skip(self, connection, values), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("SREM {} {}", key, values.join(" "))))]
+    #[instrument(name = "spin_outbound_redis.srem", skip(self, connection, values), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = "SREM"))]
     async fn srem(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -502,7 +521,8 @@ impl v2::HostConnection for crate::InstanceState {
         Ok(operations::srem(conn, key, values).await?)
     }
 
-    #[instrument(name = "spin_outbound_redis.execute", skip(self, connection, arguments), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = format!("{}", command)))]
+    #[instrument(name = "spin_outbound_redis.execute", skip(self, connection, arguments), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "redis", otel.name = command))]
     async fn execute(
         &mut self,
         connection: Resource<v2::Connection>,
diff --git a/crates/factor-sqlite/Cargo.toml b/crates/factor-sqlite/Cargo.toml
index fa98e585ba..4774898d56 100644
--- a/crates/factor-sqlite/Cargo.toml
+++ b/crates/factor-sqlite/Cargo.toml
@@ -16,6 +16,7 @@ spin-factor-otel = { path = "../factor-otel" }
 spin-factors = { path = "../factors" }
 spin-locked-app = { path = "../locked-app" }
 spin-resource-table = { path = "../table" }
+spin-telemetry = { path = "../telemetry" }
 spin-wasi-async = { path = "../wasi-async" }
 spin-world = { path = "../world" }
 tokio = { workspace = true, features = ["sync"] }
diff --git a/crates/factor-sqlite/src/host.rs b/crates/factor-sqlite/src/host.rs
index 3833984942..e4e321c24d 100644
--- a/crates/factor-sqlite/src/host.rs
+++ b/crates/factor-sqlite/src/host.rs
@@ -102,12 +102,14 @@ impl v3::Host for InstanceState {
 }
 
 impl v3::HostConnection for InstanceState {
-    #[instrument(name = "spin_sqlite.open", skip(self), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", sqlite.backend = Empty))]
+    #[instrument(name = "spin_sqlite.open", skip(self), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", sqlite.backend = Empty))]
     async fn open(&mut self, database: String) -> Result<Resource<v3::Connection>, v3::Error> {
         self.open_impl(database).await
     }
 
-    #[instrument(name = "spin_sqlite.execute", skip(self, connection, parameters), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", otel.name = query, sqlite.backend = Empty))]
+    #[instrument(name = "spin_sqlite.execute", skip(self, connection, parameters), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", sqlite.backend = Empty))]
     async fn execute(
         &mut self,
         connection: Resource<v3::Connection>,
@@ -275,13 +277,15 @@ impl v2::Host for InstanceState {
 }
 
 impl v2::HostConnection for InstanceState {
-    #[instrument(name = "spin_sqlite.open", skip(self), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", sqlite.backend = Empty))]
+    #[instrument(name = "spin_sqlite.open", skip(self), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", sqlite.backend = Empty))]
     async fn open(&mut self, database: String) -> Result<Resource<v2::Connection>, v2::Error> {
         self.otel.reparent_tracing_span();
         self.open_impl(database).await.map_err(to_v2_error)
     }
 
-    #[instrument(name = "spin_sqlite.execute", skip(self, connection, parameters), err(level = Level::INFO), fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", otel.name = query, sqlite.backend = Empty))]
+    #[instrument(name = "spin_sqlite.execute", skip(self, connection, parameters), err(level = Level::INFO),
+        fields(otel.kind = "client", {otel_attribute::DB_SYSTEM_NAME} = "sqlite", sqlite.backend = Empty))]
     async fn execute(
         &mut self,
         connection: Resource<v2::Connection>,