Move instruments up a level of abstraction in sqlite

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

Author: calebschoepp

Cargo.lock

@@ -17,6 +17,7 @@ spin-world = { path = "../world" }
 table = { path = "../table" }
 tokio = "1"
 toml = "0.8"
+tracing = { workspace = true }
 
 [dev-dependencies]
 spin-factors-test = { path = "../factors-test" }

crates/factor-sqlite/Cargo.toml

@@ -7,6 +7,8 @@ use spin_factors::wasmtime::component::Resource;
 use spin_factors::{anyhow, SelfInstanceBuilder};
 use spin_world::v1::sqlite as v1;
 use spin_world::v2::sqlite as v2;
+use tracing::field::Empty;
+use tracing::{instrument, Level};
 
 use crate::{Connection, ConnectionCreator};
 
@@ -62,6 +64,7 @@ impl v2::Host for InstanceState {
 
 #[async_trait]
 impl v2::HostConnection for InstanceState {
+    #[instrument(name = "spin_sqlite.open", skip(self), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite", sqlite.backend = Empty))]
     async fn open(&mut self, database: String) -> Result<Resource<v2::Connection>, v2::Error> {
         if !self.allowed_databases.contains(&database) {
             return Err(v2::Error::AccessDenied);
@@ -70,12 +73,17 @@ impl v2::HostConnection for InstanceState {
             .ok_or(v2::Error::NoSuchDatabase)?
             .create_connection(&database)
             .await?;
+        tracing::Span::current().record(
+            "sqlite.backend",
+            conn.summary().as_deref().unwrap_or("unknown"),
+        );
         self.connections
             .push(conn)
             .map_err(|()| v2::Error::Io("too many connections opened".to_string()))
             .map(Resource::new_own)
     }
 
+    #[instrument(name = "spin_sqlite.execute", skip(self, connection), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite", otel.name = query, sqlite.backend = Empty))]
     async fn execute(
         &mut self,
         connection: Resource<v2::Connection>,
@@ -86,6 +94,10 @@ impl v2::HostConnection for InstanceState {
             Ok(c) => c,
             Err(err) => return Err(err),
         };
+        tracing::Span::current().record(
+            "sqlite.backend",
+            conn.summary().as_deref().unwrap_or("unknown"),
+        );
         conn.query(&query, parameters).await
     }
 

crates/factor-sqlite/src/host.rs

@@ -13,7 +13,6 @@ rusqlite = { version = "0.29.0", features = ["bundled"] }
 spin-factor-sqlite = { path = "../factor-sqlite" }
 spin-world = { path = "../world" }
 tokio = "1"
-tracing = { workspace = true }
 
 [lints]
 workspace = true

crates/sqlite-inproc/Cargo.toml

@@ -8,14 +8,13 @@ use async_trait::async_trait;
 use once_cell::sync::OnceCell;
 use spin_factor_sqlite::Connection;
 use spin_world::v2::sqlite;
-use tracing::{instrument, Level};
 
 /// The location of an in-process sqlite database.
 #[derive(Debug, Clone)]
 pub enum InProcDatabaseLocation {
     /// An in-memory sqlite database.
     InMemory,
-    /// The path to the directory containing the sqlite database.
+    /// The path to the sqlite database.
     Path(PathBuf),
 }
 
@@ -74,7 +73,6 @@ impl InProcConnection {
 
 #[async_trait]
 impl Connection for InProcConnection {
-    #[instrument(name = "spin_sqlite_inproc.query", skip(self), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite", otel.name = query))]
     async fn query(
         &self,
         query: &str,
@@ -89,7 +87,6 @@ impl Connection for InProcConnection {
             .map_err(|e| sqlite::Error::Io(e.to_string()))?
     }
 
-    #[instrument(name = "spin_sqlite_inproc.execute_batch", skip(self), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite", db.statements = statements))]
     async fn execute_batch(&self, statements: &str) -> anyhow::Result<()> {
         let connection = self.db_connection()?;
         let statements = statements.to_owned();

crates/sqlite-inproc/src/lib.rs

@@ -15,7 +15,6 @@ spin-factor-sqlite = { path = "../factor-sqlite" }
 spin-world = { path = "../world" }
 sqlparser = "0.34"
 tokio = { version = "1", features = ["full"] }
-tracing = { workspace = true }
 
 [lints]
 workspace = true

crates/sqlite-libsql/Cargo.toml

@@ -4,7 +4,6 @@ use spin_factor_sqlite::Connection;
 use spin_world::v2::sqlite as v2;
 use spin_world::v2::sqlite::{self, RowResult};
 use tokio::sync::OnceCell;
-use tracing::{instrument, Level};
 
 /// A lazy wrapper around a [`LibSqlConnection`] that implements the [`Connection`] trait.
 pub struct LazyLibSqlConnection {
@@ -65,7 +64,6 @@ pub struct LibSqlConnection {
 }
 
 impl LibSqlConnection {
-    #[instrument(name = "spin_sqlite_libsql.create_connection", skip(token), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite"))]
     pub async fn create(url: String, token: String) -> anyhow::Result<Self> {
         let db = libsql::Builder::new_remote(url, token).build().await?;
         let inner = db.connect()?;
@@ -74,7 +72,6 @@ impl LibSqlConnection {
 }
 
 impl LibSqlConnection {
-    #[instrument(name = "spin_sqlite_libsql.query", skip(self), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite", otel.name = query))]
     pub async fn query(
         &self,
         query: &str,
@@ -94,7 +91,6 @@ impl LibSqlConnection {
         })
     }
 
-    #[instrument(name = "spin_sqlite_libsql.execute_batch", skip(self), err(level = Level::INFO), fields(otel.kind = "client", db.system = "sqlite", db.statements = statements))]
     pub async fn execute_batch(&self, statements: &str) -> anyhow::Result<()> {
         self.inner.execute_batch(statements).await?;