+77 -4

Cargo.lock

··· 3064 3064 3065 3065 [[package]] 3066 3066 name = "log" 3067 3067 - version = "0.4.27" 3067 3067 + version = "0.4.28" 3068 3068 source = "registry+https://github.com/rust-lang/crates.io-index" 3069 3069 - checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" 3069 3069 + checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" 3070 3070 3071 3071 [[package]] 3072 3072 name = "lru-slab" ··· 3225 3225 checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4" 3226 3226 dependencies = [ 3227 3227 "winapi", 3228 3228 + ] 3229 3229 + 3230 3230 + [[package]] 3231 3231 + name = "nu-ansi-term" 3232 3232 + version = "0.50.1" 3233 3233 + source = "registry+https://github.com/rust-lang/crates.io-index" 3234 3234 + checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399" 3235 3235 + dependencies = [ 3236 3236 + "windows-sys 0.52.0", 3228 3237 ] 3229 3238 3230 3239 [[package]] ··· 3402 3411 3403 3412 [[package]] 3404 3413 name = "owo-colors" 3405 3405 - version = "4.2.1" 3414 3414 + version = "4.2.2" 3406 3415 source = "registry+https://github.com/rust-lang/crates.io-index" 3407 3407 - checksum = "26995317201fa17f3656c36716aed4a7c81743a9634ac4c99c0eeda495db0cec" 3416 3416 + checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e" 3408 3417 dependencies = [ 3409 3418 "supports-color 2.1.0", 3410 3419 "supports-color 3.0.2", ··· 4837 4846 "sqlx", 4838 4847 "tokio", 4839 4848 "tokio-stream", 4849 4849 + "tracing", 4840 4850 ] 4841 4851 4842 4852 [[package]] ··· 4888 4898 "tempfile", 4889 4899 "tokio", 4890 4900 "tokio-stream", 4901 4901 + "tracing", 4891 4902 ] 4892 4903 4893 4904 [[package]] ··· 4919 4930 "tempfile", 4920 4931 "tokio", 4921 4932 "tokio-stream", 4933 4933 + "tracing", 4922 4934 ] 4923 4935 4924 4936 [[package]] ··· 4941 4953 "tokio", 4942 4954 "tokio-stream", 4943 4955 "tokio-tungstenite", 4956 4956 + "tracing", 4944 4957 "tungstenite", 4945 4958 "url", 4946 4959 ] ··· 4968 4981 "sqlx", 4969 4982 "tokio", 4970 4983 "tokio-stream", 4984 4984 + "tracing", 4971 4985 ] 4972 4986 4973 4987 [[package]] ··· 4995 5009 "sqlx", 4996 5010 "tokio", 4997 5011 "tokio-stream", 5012 5012 + "tracing", 4998 5013 "uuid", 4999 5014 ] 5000 5015 ··· 5018 5033 "sqlx", 5019 5034 "tokio", 5020 5035 "tokio-stream", 5036 5036 + "tracing", 5021 5037 ] 5022 5038 5023 5039 [[package]] ··· 5034 5050 "sqlx", 5035 5051 "tokio", 5036 5052 "tokio-stream", 5053 5053 + "tracing", 5037 5054 ] 5038 5055 5039 5056 [[package]] ··· 5053 5070 "serde_json", 5054 5071 "tokio", 5055 5072 "tokio-stream", 5073 5073 + "tracing", 5056 5074 "uuid", 5057 5075 ] 5058 5076 ··· 5080 5098 "sqlx", 5081 5099 "tokio", 5082 5100 "tokio-stream", 5101 5101 + "tracing", 5083 5102 ] 5084 5103 5085 5104 [[package]] ··· 5089 5108 "anyhow", 5090 5109 "clap", 5091 5110 "dotenv", 5111 5111 + "owo-colors", 5092 5112 "rocksky-analytics", 5093 5113 "rocksky-dropbox", 5094 5114 "rocksky-googledrive", ··· 5099 5119 "rocksky-tracklist", 5100 5120 "rocksky-webscrobbler", 5101 5121 "tokio", 5122 5122 + "tracing", 5123 5123 + "tracing-log", 5124 5124 + "tracing-subscriber", 5102 5125 ] 5103 5126 5104 5127 [[package]] ··· 5628 5651 "hex", 5629 5652 "sha2", 5630 5653 "tokio", 5654 5654 + ] 5655 5655 + 5656 5656 + [[package]] 5657 5657 + name = "sharded-slab" 5658 5658 + version = "0.1.7" 5659 5659 + source = "registry+https://github.com/rust-lang/crates.io-index" 5660 5660 + checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" 5661 5661 + dependencies = [ 5662 5662 + "lazy_static", 5631 5663 ] 5632 5664 5633 5665 [[package]] ··· 6441 6473 ] 6442 6474 6443 6475 [[package]] 6476 6476 + name = "thread_local" 6477 6477 + version = "1.1.9" 6478 6478 + source = "registry+https://github.com/rust-lang/crates.io-index" 6479 6479 + checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" 6480 6480 + dependencies = [ 6481 6481 + "cfg-if", 6482 6482 + ] 6483 6483 + 6484 6484 + [[package]] 6444 6485 name = "time" 6445 6486 version = "0.3.44" 6446 6487 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 6780 6821 checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" 6781 6822 dependencies = [ 6782 6823 "once_cell", 6824 6824 + "valuable", 6825 6825 + ] 6826 6826 + 6827 6827 + [[package]] 6828 6828 + name = "tracing-log" 6829 6829 + version = "0.2.0" 6830 6830 + source = "registry+https://github.com/rust-lang/crates.io-index" 6831 6831 + checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" 6832 6832 + dependencies = [ 6833 6833 + "log", 6834 6834 + "once_cell", 6835 6835 + "tracing-core", 6836 6836 + ] 6837 6837 + 6838 6838 + [[package]] 6839 6839 + name = "tracing-subscriber" 6840 6840 + version = "0.3.20" 6841 6841 + source = "registry+https://github.com/rust-lang/crates.io-index" 6842 6842 + checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5" 6843 6843 + dependencies = [ 6844 6844 + "nu-ansi-term", 6845 6845 + "sharded-slab", 6846 6846 + "smallvec", 6847 6847 + "thread_local", 6848 6848 + "tracing-core", 6849 6849 + "tracing-log", 6783 6850 ] 6784 6851 6785 6852 [[package]] ··· 6957 7024 "js-sys", 6958 7025 "wasm-bindgen", 6959 7026 ] 7027 7027 + 7028 7028 + [[package]] 7029 7029 + name = "valuable" 7030 7030 + version = "0.1.1" 7031 7031 + source = "registry+https://github.com/rust-lang/crates.io-index" 7032 7032 + checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" 6960 7033 6961 7034 [[package]] 6962 7035 name = "vcpkg"

+1

crates/analytics/Cargo.toml

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

+2 -2

crates/analytics/src/cmd/serve.rs

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

+37 -84

crates/analytics/src/core.rs

··· 194 194 .await?; 195 195 196 196 for (i, track) in tracks.clone().into_iter().enumerate() { 197 197 - println!( 198 198 - "track {} - {} - {}", 199 199 - i, 200 200 - track.title.bright_green(), 201 201 - track.artist 202 202 - ); 197 197 + tracing::info!(track = i, title = %track.title.bright_green(), artist = %track.artist); 203 198 match conn.execute( 204 199 "INSERT INTO tracks ( 205 200 id, ··· 255 250 ], 256 251 ) { 257 252 Ok(_) => (), 258 258 - Err(e) => println!("error: {}", e), 253 253 + Err(e) => tracing::error!(error = %e, "Error inserting track"), 259 254 } 260 255 } 261 256 262 262 - println!("tracks: {:?}", tracks.len()); 257 257 + tracing::info!(tracks = tracks.len(), "Loaded tracks"); 263 258 Ok(()) 264 259 } 265 260 ··· 277 272 .await?; 278 273 279 274 for (i, artist) in artists.clone().into_iter().enumerate() { 280 280 - println!("artist {} - {}", i, artist.name.bright_green()); 275 275 + tracing::info!(artist = i, name = %artist.name.bright_green()); 281 276 match conn.execute( 282 277 "INSERT INTO artists ( 283 278 id, ··· 323 318 ], 324 319 ) { 325 320 Ok(_) => (), 326 326 - Err(e) => println!("error: {}", e), 321 321 + Err(e) => tracing::error!(error = %e, "Error inserting artist"), 327 322 } 328 323 } 329 324 330 330 - println!("artists: {:?}", artists.len()); 325 325 + tracing::info!(artists = artists.len(), "Loaded artists"); 331 326 Ok(()) 332 327 } 333 328 ··· 342 337 .await?; 343 338 344 339 for (i, album) in albums.clone().into_iter().enumerate() { 345 345 - println!("album {} - {}", i, album.title.bright_green()); 340 340 + tracing::info!(album = i, title = %album.title.bright_green(), artist = %album.artist); 346 341 match conn.execute( 347 342 "INSERT INTO albums ( 348 343 id, ··· 388 383 ], 389 384 ) { 390 385 Ok(_) => (), 391 391 - Err(e) => println!("error: {}", e), 386 386 + Err(e) => tracing::error!(error = %e, "Error inserting album"), 392 387 } 393 388 } 394 389 395 395 - println!("albums: {:?}", albums.len()); 390 390 + tracing::info!(albums = albums.len(), "Loaded albums"); 396 391 Ok(()) 397 392 } 398 393 ··· 407 402 .await?; 408 403 409 404 for (i, user) in users.clone().into_iter().enumerate() { 410 410 - println!("user {} - {}", i, user.display_name.bright_green()); 405 405 + tracing::info!(user = i, name = %user.display_name.bright_green()); 411 406 match conn.execute( 412 407 "INSERT INTO users ( 413 408 id, ··· 429 424 ], 430 425 ) { 431 426 Ok(_) => (), 432 432 - Err(e) => println!("error: {}", e), 427 427 + Err(e) => tracing::error!(error = %e, "Error inserting user"), 433 428 } 434 429 } 435 430 436 436 - println!("users: {:?}", users.len()); 431 431 + tracing::info!(users = users.len(), "Loaded users"); 437 432 Ok(()) 438 433 } 439 434 ··· 451 446 .await?; 452 447 453 448 for (i, scrobble) in scrobbles.clone().into_iter().enumerate() { 454 454 - println!( 455 455 - "scrobble {} - {}", 456 456 - i, 457 457 - match scrobble.uri.clone() { 458 458 - Some(uri) => uri.to_string(), 459 459 - None => "None".to_string(), 460 460 - } 461 461 - .bright_green() 462 462 - ); 449 449 + tracing::info!(scrobble = i, uri = %scrobble.uri.clone().unwrap_or_else(|| "None".to_string()).bright_green()); 463 450 match conn.execute( 464 451 "INSERT INTO scrobbles ( 465 452 id, ··· 489 476 ], 490 477 ) { 491 478 Ok(_) => (), 492 492 - Err(e) => println!("error: {}", e), 479 479 + Err(e) => tracing::error!(error = %e, "Error inserting scrobble"), 493 480 } 494 481 } 495 482 496 496 - println!("scrobbles: {:?}", scrobbles.len()); 483 483 + tracing::info!(scrobbles = scrobbles.len(), "Loaded scrobbles"); 497 484 Ok(()) 498 485 } 499 486 ··· 511 498 .await?; 512 499 513 500 for (i, album_track) in album_tracks.clone().into_iter().enumerate() { 514 514 - println!( 515 515 - "album_track {} - {} - {}", 516 516 - i, 517 517 - album_track.album_id.bright_green(), 518 518 - album_track.track_id 519 519 - ); 501 501 + tracing::info!(album_track = i, album_id = %album_track.album_id.bright_green(), track_id = %album_track.track_id); 520 502 match conn.execute( 521 503 "INSERT INTO album_tracks ( 522 504 id, ··· 532 514 ], 533 515 ) { 534 516 Ok(_) => (), 535 535 - Err(e) => println!("error: {}", e), 517 517 + Err(e) => tracing::error!(error = %e, "Error inserting album_track"), 536 518 } 537 519 } 538 538 - println!("album_tracks: {:?}", album_tracks.len()); 520 520 + 521 521 + tracing::info!(album_tracks = album_tracks.len(), "Loaded album_tracks"); 539 522 Ok(()) 540 523 } 541 524 ··· 553 536 .await?; 554 537 555 538 for (i, loved_track) in loved_tracks.clone().into_iter().enumerate() { 556 556 - println!( 557 557 - "loved_track {} - {} - {}", 558 558 - i, 559 559 - loved_track.user_id.bright_green(), 560 560 - loved_track.track_id 561 561 - ); 539 539 + tracing::info!(loved_track = i, user_id = %loved_track.user_id.bright_green(), track_id = %loved_track.track_id); 562 540 match conn.execute( 563 541 "INSERT INTO loved_tracks ( 564 542 id, ··· 577 555 ], 578 556 ) { 579 557 Ok(_) => (), 580 580 - Err(e) => println!("error: {}", e), 558 558 + Err(e) => tracing::error!(error = %e, "Error inserting loved_track"), 581 559 } 582 560 } 583 561 584 584 - println!("loved_tracks: {:?}", loved_tracks.len()); 562 562 + tracing::info!(loved_tracks = loved_tracks.len(), "Loaded loved_tracks"); 585 563 Ok(()) 586 564 } 587 565 ··· 599 577 .await?; 600 578 601 579 for (i, artist_track) in artist_tracks.clone().into_iter().enumerate() { 602 602 - println!( 603 603 - "artist_track {} - {} - {}", 604 604 - i, 605 605 - artist_track.artist_id.bright_green(), 606 606 - artist_track.track_id 607 607 - ); 580 580 + tracing::info!(artist_track = i, artist_id = %artist_track.artist_id.bright_green(), track_id = %artist_track.track_id); 608 581 match conn.execute( 609 582 "INSERT INTO artist_tracks (id, artist_id, track_id, created_at) VALUES (?, ?, ?, ?)", 610 583 params![ ··· 615 588 ], 616 589 ) { 617 590 Ok(_) => (), 618 618 - Err(e) => println!("error: {}", e), 591 591 + Err(e) => tracing::error!(error = %e, "Error inserting artist_track"), 619 592 } 620 593 } 621 594 622 622 - println!("artist_tracks: {:?}", artist_tracks.len()); 595 595 + tracing::info!(artist_tracks = artist_tracks.len(), "Loaded artist_tracks"); 623 596 Ok(()) 624 597 } 625 598 ··· 637 610 .await?; 638 611 639 612 for (i, artist_album) in artist_albums.clone().into_iter().enumerate() { 640 640 - println!( 641 641 - "artist_albums {} - {} - {}", 642 642 - i, 643 643 - artist_album.artist_id.bright_green(), 644 644 - artist_album.album_id 645 645 - ); 613 613 + tracing::info!(artist_album = i, artist_id = %artist_album.artist_id.bright_green(), album_id = %artist_album.album_id); 646 614 match conn.execute( 647 615 "INSERT INTO artist_albums (id, artist_id, album_id, created_at) VALUES (?, ?, ?, ?)", 648 616 params![ ··· 653 621 ], 654 622 ) { 655 623 Ok(_) => (), 656 656 - Err(e) => println!("error: {}", e), 624 624 + Err(e) => tracing::error!(error = %e, "Error inserting artist_album"), 657 625 } 658 626 } 659 627 660 660 - println!("artist_albums: {:?}", artist_albums.len()); 628 628 + tracing::info!(artist_albums = artist_albums.len(), "Loaded artist_albums"); 661 629 Ok(()) 662 630 } 663 631 ··· 675 643 .await?; 676 644 677 645 for (i, user_album) in user_albums.clone().into_iter().enumerate() { 678 678 - println!( 679 679 - "user_album {} - {} - {}", 680 680 - i, 681 681 - user_album.user_id.bright_green(), 682 682 - user_album.album_id 683 683 - ); 646 646 + tracing::info!(user_album = i, user_id = %user_album.user_id.bright_green(), album_id = %user_album.album_id); 684 647 match conn.execute( 685 648 "INSERT INTO user_albums (id, user_id, album_id, created_at) VALUES (?, ?, ?, ?)", 686 649 params![ ··· 691 654 ], 692 655 ) { 693 656 Ok(_) => (), 694 694 - Err(e) => println!("error: {}", e), 657 657 + Err(e) => tracing::error!(error = %e, "Error inserting user_album"), 695 658 } 696 659 } 697 660 698 698 - println!("user_albums: {:?}", user_albums.len()); 661 661 + tracing::info!(user_albums = user_albums.len(), "Loaded user_albums"); 699 662 Ok(()) 700 663 } 701 664 ··· 713 676 .await?; 714 677 715 678 for (i, user_artist) in user_artists.clone().into_iter().enumerate() { 716 716 - println!( 717 717 - "user_artist {} - {} - {}", 718 718 - i, 719 719 - user_artist.user_id.bright_green(), 720 720 - user_artist.artist_id 721 721 - ); 679 679 + tracing::info!(user_artist = i, user_id = %user_artist.user_id.bright_green(), artist_id = %user_artist.artist_id); 722 680 match conn.execute( 723 681 "INSERT INTO user_artists (id, user_id, artist_id, created_at) VALUES (?, ?, ?, ?)", 724 682 params![ ··· 729 687 ], 730 688 ) { 731 689 Ok(_) => (), 732 732 - Err(e) => println!("error: {}", e), 690 690 + Err(e) => tracing::error!(error = %e, "Error inserting user_artist"), 733 691 } 734 692 } 735 693 736 736 - println!("user_artists: {:?}", user_artists.len()); 694 694 + tracing::info!(user_artists = user_artists.len(), "Loaded user_artists"); 737 695 Ok(()) 738 696 } 739 697 ··· 751 709 .await?; 752 710 753 711 for (i, user_track) in user_tracks.clone().into_iter().enumerate() { 754 754 - println!( 755 755 - "user_track {} - {} - {}", 756 756 - i, 757 757 - user_track.user_id.bright_green(), 758 758 - user_track.track_id 759 759 - ); 712 712 + tracing::info!(user_track = i, user_id = %user_track.user_id.bright_green(), track_id = %user_track.track_id); 760 713 match conn.execute( 761 714 "INSERT INTO user_tracks (id, user_id, track_id, created_at) VALUES (?, ?, ?, ?)", 762 715 params![ ··· 767 720 ], 768 721 ) { 769 722 Ok(_) => (), 770 770 - Err(e) => println!("error: {}", e), 723 723 + Err(e) => tracing::error!(error = %e, "Error inserting user_track"), 771 724 } 772 725 } 773 726 774 774 - println!("user_tracks: {:?}", user_tracks.len()); 727 727 + tracing::info!(user_tracks = user_tracks.len(), "Loaded user_tracks"); 775 728 Ok(()) 776 729 }

+4

crates/analytics/src/handlers/albums.rs

··· 22 22 let offset = pagination.skip.unwrap_or(0); 23 23 let limit = pagination.take.unwrap_or(20); 24 24 let did = params.user_did; 25 25 + tracing::info!(limit, offset, user_did = ?did, "Get albums"); 25 26 26 27 let conn = conn.lock().unwrap(); 27 28 let mut stmt = match did { ··· 118 119 let offset = pagination.skip.unwrap_or(0); 119 120 let limit = pagination.take.unwrap_or(20); 120 121 let did = params.user_did; 122 122 + tracing::info!(limit, offset, user_did = ?did, "Get top albums"); 121 123 122 124 let conn = conn.lock().unwrap(); 123 125 let mut stmt = match did { ··· 237 239 let body = read_payload!(payload); 238 240 let params = serde_json::from_slice::<GetAlbumTracksParams>(&body)?; 239 241 let conn = conn.lock().unwrap(); 242 242 + tracing::info!(album_id = %params.album_id, "Get album tracks"); 243 243 + 240 244 let mut stmt = conn.prepare(r#" 241 245 SELECT 242 246 t.id,

+2

crates/analytics/src/handlers/artists.rs

··· 318 318 let body = read_payload!(payload); 319 319 let params = serde_json::from_slice::<GetArtistAlbumsParams>(&body)?; 320 320 let conn = conn.lock().unwrap(); 321 321 + tracing::info!(artist_id = %params.artist_id, "Get artist albums"); 321 322 322 323 let mut stmt = conn.prepare(r#" 323 324 SELECT ··· 376 377 let pagination = params.pagination.unwrap_or_default(); 377 378 let offset = pagination.skip.unwrap_or(0); 378 379 let limit = pagination.take.unwrap_or(10); 380 380 + tracing::info!(artist_id = %params.artist_id, limit, offset, "Get artist listeners"); 379 381 380 382 let conn = conn.lock().unwrap(); 381 383 let mut stmt =

+2

crates/analytics/src/handlers/scrobbles.rs

··· 19 19 let offset = pagination.skip.unwrap_or(0); 20 20 let limit = pagination.take.unwrap_or(20); 21 21 let did = params.user_did; 22 22 + tracing::info!(limit, offset, user_did = ?did, "Get scrobbles"); 22 23 23 24 let conn = conn.lock().unwrap(); 24 25 let mut stmt = match did { ··· 139 140 let pagination = params.pagination.unwrap_or_default(); 140 141 let offset = pagination.skip.unwrap_or(0); 141 142 let limit = pagination.take.unwrap_or(10); 143 143 + tracing::info!(limit, offset, user_did = ?params.user_did, "Get distinct scrobbles"); 142 144 143 145 let conn = conn.lock().unwrap(); 144 146 let mut stmt = conn.prepare(

+8

crates/analytics/src/handlers/stats.rs

··· 23 23 let body = read_payload!(payload); 24 24 25 25 let params = serde_json::from_slice::<GetStatsParams>(&body)?; 26 26 + tracing::info!(user_did = ?params.user_did, "Get stats"); 26 27 27 28 let conn = conn.lock().unwrap(); 28 29 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 = ?")?; ··· 118 119 .end 119 120 .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 120 121 let did = params.user_did; 122 122 + tracing::info!(start = %start, end = %end, user_did = ?did, "Get scrobbles per day"); 121 123 122 124 let conn = conn.lock().unwrap(); 123 125 match did { ··· 190 192 .end 191 193 .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 192 194 let did = params.user_did; 195 195 + tracing::info!(start = %start, end = %end, user_did = ?did, "Get scrobbles per month"); 193 196 194 197 let conn = conn.lock().unwrap(); 195 198 match did { ··· 266 269 .end 267 270 .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 268 271 let did = params.user_did; 272 272 + tracing::info!(start = %start, end = %end, user_did = ?did, "Get scrobbles per year"); 269 273 270 274 let conn = conn.lock().unwrap(); 271 275 match did { ··· 338 342 .end 339 343 .unwrap_or(GetAlbumScrobblesParams::default().end.unwrap()); 340 344 let conn = conn.lock().unwrap(); 345 345 + tracing::info!(album_id = %params.album_id, start = %start, end = %end, "Get album scrobbles"); 346 346 + 341 347 let mut stmt = conn.prepare( 342 348 r#" 343 349 SELECT ··· 379 385 .end 380 386 .unwrap_or(GetArtistScrobblesParams::default().end.unwrap()); 381 387 let conn = conn.lock().unwrap(); 388 388 + tracing::info!(artist_id = %params.artist_id, start = %start, end = %end, "Get artist scrobbles"); 382 389 383 390 let mut stmt = conn.prepare( 384 391 r#" ··· 426 433 .end 427 434 .unwrap_or(GetTrackScrobblesParams::default().end.unwrap()); 428 435 let conn = conn.lock().unwrap(); 436 436 + tracing::info!(track_id = %params.track_id, start = %start, end = %end, "Get track scrobbles"); 429 437 430 438 let mut stmt = conn.prepare( 431 439 r#"

+3

crates/analytics/src/handlers/tracks.rs

··· 19 19 let offset = pagination.skip.unwrap_or(0); 20 20 let limit = pagination.take.unwrap_or(20); 21 21 let did = params.user_did; 22 22 + tracing::info!(limit, offset, user_did = ?did, "Get tracks"); 22 23 23 24 let conn = conn.lock().unwrap(); 24 25 match did { ··· 178 179 let offset = pagination.skip.unwrap_or(0); 179 180 let limit = pagination.take.unwrap_or(20); 180 181 let did = params.user_did; 182 182 + tracing::info!(limit, offset, user_did = ?did, "Get loved tracks"); 181 183 182 184 let conn = conn.lock().unwrap(); 183 185 let mut stmt = conn.prepare( ··· 261 263 let offset = pagination.skip.unwrap_or(0); 262 264 let limit = pagination.take.unwrap_or(20); 263 265 let did = params.user_did; 266 266 + tracing::info!(limit, offset, user_did = ?did, "Get top tracks"); 264 267 265 268 let conn = conn.lock().unwrap(); 266 269 match did {

+7 -7

crates/analytics/src/subscriber/mod.rs

··· 16 16 let addr = env::var("NATS_URL").unwrap_or_else(|_| "nats://localhost:4222".to_string()); 17 17 let conn = conn.clone(); 18 18 let nc = connect(&addr).await?; 19 19 - println!("Connected to NATS server at {}", addr.bright_green()); 19 19 + tracing::info!(server = %addr.bright_green(), "Connected to NATS"); 20 20 21 21 let nc = Arc::new(Mutex::new(nc)); 22 22 on_scrobble(nc.clone(), conn.clone()); ··· 652 652 Ok(_) => (), 653 653 Err(e) => { 654 654 if !e.to_string().contains("violates primary key constraint") { 655 655 - println!("[artist_albums] error: {}", e); 655 655 + tracing::error!("[artist_albums] error: {}", e); 656 656 return Err(e.into()); 657 657 } 658 658 } ··· 684 684 Ok(_) => (), 685 685 Err(e) => { 686 686 if !e.to_string().contains("violates primary key constraint") { 687 687 - println!("[likes] error: {}", e); 687 687 + tracing::error!("[likes] error: {}", e); 688 688 return Err(e.into()); 689 689 } 690 690 } ··· 700 700 ) { 701 701 Ok(_) => (), 702 702 Err(e) => { 703 703 - println!("[unlikes] error: {}", e); 703 703 + tracing::error!("[unlikes] error: {}", e); 704 704 return Err(e.into()); 705 705 } 706 706 } ··· 740 740 Ok(_) => (), 741 741 Err(e) => { 742 742 if !e.to_string().contains("violates primary key constraint") { 743 743 - println!("[users] error: {}", e); 743 743 + tracing::error!("[users] error: {}", e); 744 744 return Err(e.into()); 745 745 } 746 746 } ··· 921 921 922 922 match serde_json::from_str::<types::ScrobblePayload>(data) { 923 923 Err(e) => { 924 924 - eprintln!("Error parsing payload: {}", e); 925 925 - println!("{}", data); 924 924 + tracing::error!("Error parsing payload: {}", e); 925 925 + tracing::error!("{}", data); 926 926 } 927 927 Ok(_) => {} 928 928 }

+1

crates/dropbox/Cargo.toml

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

+1

crates/googledrive/Cargo.toml

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

+1

crates/jetstream/Cargo.toml

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

+1

crates/playlists/Cargo.toml

··· 37 37 hex = "0.4.3" 38 38 jsonwebtoken = "9.3.1" 39 39 sha2 = "0.10.8" 40 40 + tracing = "0.1.41"

+4

crates/rockskyd/Cargo.toml

··· 20 20 rocksky-spotify = { path = "../spotify" } 21 21 rocksky-tracklist = { path = "../tracklist" } 22 22 rocksky-webscrobbler = { path = "../webscrobbler" } 23 23 + tracing = "0.1.41" 24 24 + tracing-subscriber = "0.3.20" 25 25 + tracing-log = "0.2.0" 26 26 + owo-colors = "4.2.2"

+12

crates/rockskyd/src/main.rs

··· 1 1 use clap::Command; 2 2 use dotenv::dotenv; 3 3 + use tracing_subscriber::fmt::format::Format; 3 4 4 5 pub mod cmd; 5 6 ··· 35 36 36 37 #[tokio::main] 37 38 async fn main() -> Result<(), Box<dyn std::error::Error>> { 39 39 + let format = Format::default() 40 40 + .with_level(true) 41 41 + .with_target(true) 42 42 + .with_ansi(true) 43 43 + .compact(); 44 44 + 45 45 + tracing_subscriber::fmt() 46 46 + .event_format(format) 47 47 + .with_max_level(tracing::Level::INFO) 48 48 + .init(); 49 49 + 38 50 dotenv().ok(); 39 51 40 52 let args = cli().get_matches();

+1

crates/scrobbler/Cargo.toml

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

+1

crates/spotify/Cargo.toml

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

+1

crates/storage/Cargo.toml

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

+1

crates/tracklist/Cargo.toml

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

+1

crates/webscrobbler/Cargo.toml

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