feat: use tracing for logs

- We protect against ever compiling log statements into
release binaries

Author: pmorris-dev

Cargo.lock

@@ -81,7 +81,7 @@ Run Rust tests:
 cargo test
 ```
 
-### Linting and standards checks
+### Linting and Standards Checks
 
 ```bash
 npm run standards
@@ -109,6 +109,51 @@ fn main() {
 }
 ```
 
+### Tracing and Logging
+
+This plugin and its connection manager crate use the
+[`tracing`](https://crates.io/crates/tracing) ecosystem for internal logging. They are
+configured with the `release_max_level_off` feature so that **all log statements are
+compiled out of release builds**. This guarantees that logging from this plugin will never
+reach production binaries unless you explicitly change that configuration.
+
+To see logs during development, initialize a `tracing-subscriber` in your Tauri
+application crate and keep it behind a `debug_assertions` guard, for example:
+
+```toml
+[dependencies]
+tracing = { version = "0.1.41", default-features = false, features = ["std", "release_max_level_off"] }
+tracing-subscriber = { version = "0.3.20", features = ["fmt", "env-filter"] }
+```
+
+```rust
+#[cfg(debug_assertions)]
+fn init_tracing() {
+    use tracing_subscriber::{fmt, EnvFilter};
+
+    let filter = EnvFilter::try_from_default_env()
+        .unwrap_or_else(|_| EnvFilter::new("trace"));
+
+    fmt().with_env_filter(filter).compact().init();
+}
+
+#[cfg(not(debug_assertions))]
+fn init_tracing() {}
+
+fn main() {
+    init_tracing();
+
+    tauri::Builder::default()
+        .plugin(tauri_plugin_sqlite::init())
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+With this setup, `tauri dev` shows all plugin and app logs, while `tauri build` produces
+a release binary that contains no logging from this plugin or your app-level `tracing`
+calls.
+
 ### JavaScript/TypeScript API
 
 Install the JavaScript package in your frontend:

README.md

@@ -10,3 +10,4 @@ rust-version = "1.89"
 sqlx = { version = "0.8.6", features = ["runtime-tokio", "sqlite"] }
 thiserror = "2.0.17"
 tokio = { version = "1.48.0", features = ["full"] }
+tracing = { version = "0.1.41", default-features = false, features = ["std", "release_max_level_off"] }

crates/sqlx-sqlite-conn-mgr/Cargo.toml

@@ -154,6 +154,14 @@ queries.
    * Idle timeout: 30 seconds by default (configurable via `custom_config`)
    * Only customize `SqliteDatabaseConfig` when defaults don't meet your needs
 
+## Tracing and Logging
+
+This crate uses the [`tracing`](https://crates.io/crates/tracing) ecosystem for internal
+instrumentation. It is built with the `release_max_level_off` feature so that all
+`tracing` log statements are compiled out of release builds. To see its logs during
+development, the host application must install a `tracing-subscriber` and enable the
+desired log level; no extra configuration is required in this crate.
+
 ## Error Handling
 
 ```rust

crates/sqlx-sqlite-conn-mgr/README.md

@@ -10,6 +10,7 @@ use sqlx::{ConnectOptions, Pool, Sqlite};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use tracing::error;
 
 /// SQLite database with connection pooling for concurrent reads and optional exclusive writes.
 ///
@@ -273,11 +274,7 @@ impl SqliteDatabase {
 
       // Remove from registry
       if let Err(e) = uncache_database(&self.path).await {
-         // TODO: Investigate use of "tracing" crate to log this error
-         #[cfg(debug_assertions)]
-         eprintln!("Failed to remove database from cache: {}", e);
-         #[cfg(not(debug_assertions))]
-         let _ = e; // Suppress unused variable warning
+         error!("Failed to remove database from cache: {}", e);
       }
 
       // This will await all readers to be returned