feat: update dependencies to include tracing and improve logging throughout the application

Cargo.lock

···
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "lru-slab"
···
 checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4"
 dependencies = [
  "winapi",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
+dependencies = [
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "owo-colors"
-version = "4.2.1"
+version = "4.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26995317201fa17f3656c36716aed4a7c81743a9634ac4c99c0eeda495db0cec"
+checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e"
 dependencies = [
  "supports-color 2.1.0",
  "supports-color 3.0.2",
···
  "sqlx",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "tempfile",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "tempfile",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "tokio",
  "tokio-stream",
  "tokio-tungstenite",
+ "tracing",
  "tungstenite",
  "url",
 ]
···
  "sqlx",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "sqlx",
  "tokio",
  "tokio-stream",
+ "tracing",
  "uuid",
 ]
 
···
  "sqlx",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "sqlx",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "serde_json",
  "tokio",
  "tokio-stream",
+ "tracing",
  "uuid",
 ]
 
···
  "sqlx",
  "tokio",
  "tokio-stream",
+ "tracing",
 ]
 
 [[package]]
···
  "anyhow",
  "clap",
  "dotenv",
+ "owo-colors",
  "rocksky-analytics",
  "rocksky-dropbox",
  "rocksky-googledrive",
···
  "rocksky-tracklist",
  "rocksky-webscrobbler",
  "tokio",
+ "tracing",
+ "tracing-log",
+ "tracing-subscriber",
 ]
 
 [[package]]
···
  "hex",
  "sha2",
  "tokio",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
 name = "time"
 version = "0.3.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
+dependencies = [
+ "nu-ansi-term",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
···
  "js-sys",
  "wasm-bindgen",
 ]
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
 name = "vcpkg"

crates/analytics/Cargo.toml

···
 clap = "4.5.31"
 actix-web = "4.9.0"
 tokio-stream = { version = "0.1.17", features = ["full"] }
+tracing = "0.1.41"

crates/analytics/src/cmd/serve.rs

···
     req: HttpRequest,
 ) -> Result<impl Responder, actix_web::Error> {
     let method = req.match_info().get("method").unwrap_or("unknown");
-    println!("Method: {}", method.bright_green());
+    tracing::info!(method = %method.bright_green(), "API call");
 
     let conn = data.get_ref().clone();
     handle(method, &mut payload, &req, conn)
···
     let addr = format!("{}:{}", host, port);
 
     let url = format!("http://{}", addr);
-    println!("Listening on {}", url.bright_green());
+    tracing::info!(url = %url.bright_green(), "Listening on");
 
     let conn = conn.clone();
     HttpServer::new(move || {

crates/analytics/src/core.rs

···
     .await?;
 
     for (i, track) in tracks.clone().into_iter().enumerate() {
-        println!(
-            "track {} - {} - {}",
-            i,
-            track.title.bright_green(),
-            track.artist
-        );
+        tracing::info!(track = i, title = %track.title.bright_green(), artist = %track.artist);
         match conn.execute(
             "INSERT INTO tracks (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting track"),
         }
     }
 
-    println!("tracks: {:?}", tracks.len());
+    tracing::info!(tracks = tracks.len(), "Loaded tracks");
     Ok(())
 }
 
···
     .await?;
 
     for (i, artist) in artists.clone().into_iter().enumerate() {
-        println!("artist {} - {}", i, artist.name.bright_green());
+        tracing::info!(artist = i, name = %artist.name.bright_green());
         match conn.execute(
             "INSERT INTO artists (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting artist"),
         }
     }
 
-    println!("artists: {:?}", artists.len());
+    tracing::info!(artists = artists.len(), "Loaded artists");
     Ok(())
 }
 
···
     .await?;
 
     for (i, album) in albums.clone().into_iter().enumerate() {
-        println!("album {} - {}", i, album.title.bright_green());
+        tracing::info!(album = i, title = %album.title.bright_green(), artist = %album.artist);
         match conn.execute(
             "INSERT INTO albums (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting album"),
         }
     }
 
-    println!("albums: {:?}", albums.len());
+    tracing::info!(albums = albums.len(), "Loaded albums");
     Ok(())
 }
 
···
     .await?;
 
     for (i, user) in users.clone().into_iter().enumerate() {
-        println!("user {} - {}", i, user.display_name.bright_green());
+        tracing::info!(user = i, name = %user.display_name.bright_green());
         match conn.execute(
             "INSERT INTO users (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting user"),
         }
     }
 
-    println!("users: {:?}", users.len());
+    tracing::info!(users = users.len(), "Loaded users");
     Ok(())
 }
 
···
     .await?;
 
     for (i, scrobble) in scrobbles.clone().into_iter().enumerate() {
-        println!(
-            "scrobble {} - {}",
-            i,
-            match scrobble.uri.clone() {
-                Some(uri) => uri.to_string(),
-                None => "None".to_string(),
-            }
-            .bright_green()
-        );
+        tracing::info!(scrobble = i, uri = %scrobble.uri.clone().unwrap_or_else(|| "None".to_string()).bright_green());
         match conn.execute(
             "INSERT INTO scrobbles (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting scrobble"),
         }
     }
 
-    println!("scrobbles: {:?}", scrobbles.len());
+    tracing::info!(scrobbles = scrobbles.len(), "Loaded scrobbles");
     Ok(())
 }
 
···
     .await?;
 
     for (i, album_track) in album_tracks.clone().into_iter().enumerate() {
-        println!(
-            "album_track {} - {} - {}",
-            i,
-            album_track.album_id.bright_green(),
-            album_track.track_id
-        );
+        tracing::info!(album_track = i, album_id = %album_track.album_id.bright_green(), track_id = %album_track.track_id);
         match conn.execute(
             "INSERT INTO album_tracks (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting album_track"),
         }
     }
-    println!("album_tracks: {:?}", album_tracks.len());
+
+    tracing::info!(album_tracks = album_tracks.len(), "Loaded album_tracks");
     Ok(())
 }
 
···
     .await?;
 
     for (i, loved_track) in loved_tracks.clone().into_iter().enumerate() {
-        println!(
-            "loved_track {} - {} - {}",
-            i,
-            loved_track.user_id.bright_green(),
-            loved_track.track_id
-        );
+        tracing::info!(loved_track = i, user_id = %loved_track.user_id.bright_green(), track_id = %loved_track.track_id);
         match conn.execute(
             "INSERT INTO loved_tracks (
               id,
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting loved_track"),
         }
     }
 
-    println!("loved_tracks: {:?}", loved_tracks.len());
+    tracing::info!(loved_tracks = loved_tracks.len(), "Loaded loved_tracks");
     Ok(())
 }
 
···
     .await?;
 
     for (i, artist_track) in artist_tracks.clone().into_iter().enumerate() {
-        println!(
-            "artist_track {} - {} - {}",
-            i,
-            artist_track.artist_id.bright_green(),
-            artist_track.track_id
-        );
+        tracing::info!(artist_track = i, artist_id = %artist_track.artist_id.bright_green(), track_id = %artist_track.track_id);
         match conn.execute(
             "INSERT INTO artist_tracks (id, artist_id, track_id, created_at) VALUES (?, ?, ?, ?)",
             params![
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting artist_track"),
         }
     }
 
-    println!("artist_tracks: {:?}", artist_tracks.len());
+    tracing::info!(artist_tracks = artist_tracks.len(), "Loaded artist_tracks");
     Ok(())
 }
 
···
     .await?;
 
     for (i, artist_album) in artist_albums.clone().into_iter().enumerate() {
-        println!(
-            "artist_albums {} - {} - {}",
-            i,
-            artist_album.artist_id.bright_green(),
-            artist_album.album_id
-        );
+        tracing::info!(artist_album = i, artist_id = %artist_album.artist_id.bright_green(), album_id = %artist_album.album_id);
         match conn.execute(
             "INSERT INTO artist_albums (id, artist_id, album_id, created_at) VALUES (?, ?, ?, ?)",
             params![
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting artist_album"),
         }
     }
 
-    println!("artist_albums: {:?}", artist_albums.len());
+    tracing::info!(artist_albums = artist_albums.len(), "Loaded artist_albums");
     Ok(())
 }
 
···
     .await?;
 
     for (i, user_album) in user_albums.clone().into_iter().enumerate() {
-        println!(
-            "user_album {} - {} - {}",
-            i,
-            user_album.user_id.bright_green(),
-            user_album.album_id
-        );
+        tracing::info!(user_album = i, user_id = %user_album.user_id.bright_green(), album_id = %user_album.album_id);
         match conn.execute(
             "INSERT INTO user_albums (id, user_id, album_id, created_at) VALUES (?, ?, ?, ?)",
             params![
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting user_album"),
         }
     }
 
-    println!("user_albums: {:?}", user_albums.len());
+    tracing::info!(user_albums = user_albums.len(), "Loaded user_albums");
     Ok(())
 }
 
···
     .await?;
 
     for (i, user_artist) in user_artists.clone().into_iter().enumerate() {
-        println!(
-            "user_artist {} - {} - {}",
-            i,
-            user_artist.user_id.bright_green(),
-            user_artist.artist_id
-        );
+        tracing::info!(user_artist = i, user_id = %user_artist.user_id.bright_green(), artist_id = %user_artist.artist_id);
         match conn.execute(
             "INSERT INTO user_artists (id, user_id, artist_id, created_at) VALUES (?, ?, ?, ?)",
             params![
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting user_artist"),
         }
     }
 
-    println!("user_artists: {:?}", user_artists.len());
+    tracing::info!(user_artists = user_artists.len(), "Loaded user_artists");
     Ok(())
 }
 
···
     .await?;
 
     for (i, user_track) in user_tracks.clone().into_iter().enumerate() {
-        println!(
-            "user_track {} - {} - {}",
-            i,
-            user_track.user_id.bright_green(),
-            user_track.track_id
-        );
+        tracing::info!(user_track = i, user_id = %user_track.user_id.bright_green(), track_id = %user_track.track_id);
         match conn.execute(
             "INSERT INTO user_tracks (id, user_id, track_id, created_at) VALUES (?, ?, ?, ?)",
             params![
···
             ],
         ) {
             Ok(_) => (),
-            Err(e) => println!("error: {}", e),
+            Err(e) => tracing::error!(error = %e, "Error inserting user_track"),
         }
     }
 
-    println!("user_tracks: {:?}", user_tracks.len());
+    tracing::info!(user_tracks = user_tracks.len(), "Loaded user_tracks");
     Ok(())
 }

crates/analytics/src/handlers/albums.rs

···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    tracing::info!(limit, offset, user_did = ?did, "Get albums");
 
     let conn = conn.lock().unwrap();
     let mut stmt = match did {
···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    tracing::info!(limit, offset, user_did = ?did, "Get top albums");
 
     let conn = conn.lock().unwrap();
     let mut stmt = match did {
···
     let body = read_payload!(payload);
     let params = serde_json::from_slice::<GetAlbumTracksParams>(&body)?;
     let conn = conn.lock().unwrap();
+    tracing::info!(album_id = %params.album_id, "Get album tracks");
+
     let mut stmt = conn.prepare(r#"
     SELECT
       t.id,

crates/analytics/src/handlers/artists.rs

···
     let body = read_payload!(payload);
     let params = serde_json::from_slice::<GetArtistAlbumsParams>(&body)?;
     let conn = conn.lock().unwrap();
+    tracing::info!(artist_id = %params.artist_id, "Get artist albums");
 
     let mut stmt = conn.prepare(r#"
         SELECT
···
     let pagination = params.pagination.unwrap_or_default();
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(10);
+    tracing::info!(artist_id = %params.artist_id, limit, offset, "Get artist listeners");
 
     let conn = conn.lock().unwrap();
     let mut stmt =

crates/analytics/src/handlers/scrobbles.rs

···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    tracing::info!(limit, offset, user_did = ?did, "Get scrobbles");
 
     let conn = conn.lock().unwrap();
     let mut stmt = match did {
···
     let pagination = params.pagination.unwrap_or_default();
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(10);
+    tracing::info!(limit, offset, user_did = ?params.user_did, "Get distinct scrobbles");
 
     let conn = conn.lock().unwrap();
     let mut stmt = conn.prepare(

crates/analytics/src/handlers/stats.rs

···
     let body = read_payload!(payload);
 
     let params = serde_json::from_slice::<GetStatsParams>(&body)?;
+    tracing::info!(user_did = ?params.user_did, "Get stats");
 
     let conn = conn.lock().unwrap();
     let mut stmt = conn.prepare("SELECT COUNT(*) FROM scrobbles s LEFT JOIN users u ON s.user_id = u.id WHERE u.did = ? OR u.handle = ?")?;
···
         .end
         .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap());
     let did = params.user_did;
+    tracing::info!(start = %start, end = %end, user_did = ?did, "Get scrobbles per day");
 
     let conn = conn.lock().unwrap();
     match did {
···
         .end
         .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap());
     let did = params.user_did;
+    tracing::info!(start = %start, end = %end, user_did = ?did, "Get scrobbles per month");
 
     let conn = conn.lock().unwrap();
     match did {
···
         .end
         .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap());
     let did = params.user_did;
+    tracing::info!(start = %start, end = %end, user_did = ?did, "Get scrobbles per year");
 
     let conn = conn.lock().unwrap();
     match did {
···
         .end
         .unwrap_or(GetAlbumScrobblesParams::default().end.unwrap());
     let conn = conn.lock().unwrap();
+    tracing::info!(album_id = %params.album_id, start = %start, end = %end, "Get album scrobbles");
+
     let mut stmt = conn.prepare(
         r#"
         SELECT
···
         .end
         .unwrap_or(GetArtistScrobblesParams::default().end.unwrap());
     let conn = conn.lock().unwrap();
+    tracing::info!(artist_id = %params.artist_id, start = %start, end = %end, "Get artist scrobbles");
 
     let mut stmt = conn.prepare(
         r#"
···
         .end
         .unwrap_or(GetTrackScrobblesParams::default().end.unwrap());
     let conn = conn.lock().unwrap();
+    tracing::info!(track_id = %params.track_id, start = %start, end = %end, "Get track scrobbles");
 
     let mut stmt = conn.prepare(
         r#"

crates/analytics/src/handlers/tracks.rs

···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    tracing::info!(limit, offset, user_did = ?did, "Get tracks");
 
     let conn = conn.lock().unwrap();
     match did {
···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    tracing::info!(limit, offset, user_did = ?did, "Get loved tracks");
 
     let conn = conn.lock().unwrap();
     let mut stmt = conn.prepare(
···
     let offset = pagination.skip.unwrap_or(0);
     let limit = pagination.take.unwrap_or(20);
     let did = params.user_did;
+    tracing::info!(limit, offset, user_did = ?did, "Get top tracks");
 
     let conn = conn.lock().unwrap();
     match did {

crates/analytics/src/subscriber/mod.rs

···
     let addr = env::var("NATS_URL").unwrap_or_else(|_| "nats://localhost:4222".to_string());
     let conn = conn.clone();
     let nc = connect(&addr).await?;
-    println!("Connected to NATS server at {}", addr.bright_green());
+    tracing::info!(server = %addr.bright_green(), "Connected to NATS");
 
     let nc = Arc::new(Mutex::new(nc));
     on_scrobble(nc.clone(), conn.clone());
···
         Ok(_) => (),
         Err(e) => {
             if !e.to_string().contains("violates primary key constraint") {
-                println!("[artist_albums] error: {}", e);
+                tracing::error!("[artist_albums] error: {}", e);
                 return Err(e.into());
             }
         }
···
         Ok(_) => (),
         Err(e) => {
             if !e.to_string().contains("violates primary key constraint") {
-                println!("[likes] error: {}", e);
+                tracing::error!("[likes] error: {}", e);
                 return Err(e.into());
             }
         }
···
     ) {
         Ok(_) => (),
         Err(e) => {
-            println!("[unlikes] error: {}", e);
+            tracing::error!("[unlikes] error: {}", e);
             return Err(e.into());
         }
     }
···
         Ok(_) => (),
         Err(e) => {
             if !e.to_string().contains("violates primary key constraint") {
-                println!("[users] error: {}", e);
+                tracing::error!("[users] error: {}", e);
                 return Err(e.into());
             }
         }
···
 
         match serde_json::from_str::<types::ScrobblePayload>(data) {
             Err(e) => {
-                eprintln!("Error parsing payload: {}", e);
-                println!("{}", data);
+                tracing::error!("Error parsing payload: {}", e);
+                tracing::error!("{}", data);
             }
             Ok(_) => {}
         }

crates/dropbox/Cargo.toml

···
 tempfile = "3.19.1"
 tokio = { version = "1.43.0", features = ["full"] }
 tokio-stream = { version = "0.1.17", features = ["full"] }
+tracing = "0.1.41"

crates/googledrive/Cargo.toml

···
 tempfile = "3.19.1"
 tokio = { version = "1.43.0", features = ["full"] }
 tokio-stream = { version = "0.1.17", features = ["full"] }
+tracing = "0.1.41"

crates/jetstream/Cargo.toml

···
 sha256 = "1.6.0"
 time = { version = "0.3.44", features = ["formatting", "macros"] }
 redis = { version = "0.29.0", features = ["aio", "tokio-comp"] }
+tracing = "0.1.41"

crates/playlists/Cargo.toml

···
 hex = "0.4.3"
 jsonwebtoken = "9.3.1"
 sha2 = "0.10.8"
+tracing = "0.1.41"

crates/rockskyd/Cargo.toml

···
 rocksky-spotify = { path = "../spotify" }
 rocksky-tracklist = { path = "../tracklist" }
 rocksky-webscrobbler = { path = "../webscrobbler" }
+tracing = "0.1.41"
+tracing-subscriber = "0.3.20"
+tracing-log = "0.2.0"
+owo-colors = "4.2.2"

crates/rockskyd/src/main.rs

···
 use clap::Command;
 use dotenv::dotenv;
+use tracing_subscriber::fmt::format::Format;
 
 pub mod cmd;
 
···
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let format = Format::default()
+        .with_level(true)
+        .with_target(true)
+        .with_ansi(true)
+        .compact();
+
+    tracing_subscriber::fmt()
+        .event_format(format)
+        .with_max_level(tracing::Level::INFO)
+        .init();
+
     dotenv().ok();
 
     let args = cli().get_matches();

crates/scrobbler/Cargo.toml

···
 actix-limitation = "0.5.1"
 actix-session = "0.10.1"
 tokio-stream = { version = "0.1.17", features = ["full"] }
+tracing = "0.1.41"

crates/spotify/Cargo.toml

···
 ] }
 tokio = { version = "1.43.0", features = ["full"] }
 tokio-stream = { version = "0.1.17", features = ["full"] }
+tracing = "0.1.41"

crates/storage/Cargo.toml

···
 ] }
 actix-web = "4.9.0"
 tokio-stream = { version = "0.1.17", features = ["full"] }
+tracing = "0.1.41"

crates/tracklist/Cargo.toml

···
 clap = "4.5.31"
 rand = "0.9.2"
 uuid = { version = "1.18.0", features = ["v4"] }
+tracing = "0.1.41"

crates/webscrobbler/Cargo.toml

···
 tokio-stream = { version = "0.1.17", features = ["full"] }
 actix-session = "0.10.1"
 actix-limitation = "0.5.1"
+tracing = "0.1.41"