+77 -4

Cargo.lock

··· 3064 3065 [[package]] 3066 name = "log" 3067 - version = "0.4.27" 3068 source = "registry+https://github.com/rust-lang/crates.io-index" 3069 - checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" 3070 3071 [[package]] 3072 name = "lru-slab" ··· 3225 checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4" 3226 dependencies = [ 3227 "winapi", 0 0 0 0 0 0 0 0 0 3228 ] 3229 3230 [[package]] ··· 3402 3403 [[package]] 3404 name = "owo-colors" 3405 - version = "4.2.1" 3406 source = "registry+https://github.com/rust-lang/crates.io-index" 3407 - checksum = "26995317201fa17f3656c36716aed4a7c81743a9634ac4c99c0eeda495db0cec" 3408 dependencies = [ 3409 "supports-color 2.1.0", 3410 "supports-color 3.0.2", ··· 4837 "sqlx", 4838 "tokio", 4839 "tokio-stream", 0 4840 ] 4841 4842 [[package]] ··· 4888 "tempfile", 4889 "tokio", 4890 "tokio-stream", 0 4891 ] 4892 4893 [[package]] ··· 4919 "tempfile", 4920 "tokio", 4921 "tokio-stream", 0 4922 ] 4923 4924 [[package]] ··· 4941 "tokio", 4942 "tokio-stream", 4943 "tokio-tungstenite", 0 4944 "tungstenite", 4945 "url", 4946 ] ··· 4968 "sqlx", 4969 "tokio", 4970 "tokio-stream", 0 4971 ] 4972 4973 [[package]] ··· 4995 "sqlx", 4996 "tokio", 4997 "tokio-stream", 0 4998 "uuid", 4999 ] 5000 ··· 5018 "sqlx", 5019 "tokio", 5020 "tokio-stream", 0 5021 ] 5022 5023 [[package]] ··· 5034 "sqlx", 5035 "tokio", 5036 "tokio-stream", 0 5037 ] 5038 5039 [[package]] ··· 5053 "serde_json", 5054 "tokio", 5055 "tokio-stream", 0 5056 "uuid", 5057 ] 5058 ··· 5080 "sqlx", 5081 "tokio", 5082 "tokio-stream", 0 5083 ] 5084 5085 [[package]] ··· 5089 "anyhow", 5090 "clap", 5091 "dotenv", 0 5092 "rocksky-analytics", 5093 "rocksky-dropbox", 5094 "rocksky-googledrive", ··· 5099 "rocksky-tracklist", 5100 "rocksky-webscrobbler", 5101 "tokio", 0 0 0 5102 ] 5103 5104 [[package]] ··· 5628 "hex", 5629 "sha2", 5630 "tokio", 0 0 0 0 0 0 0 0 0 5631 ] 5632 5633 [[package]] ··· 6441 ] 6442 6443 [[package]] 0 0 0 0 0 0 0 0 0 6444 name = "time" 6445 version = "0.3.44" 6446 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 6780 checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" 6781 dependencies = [ 6782 "once_cell", 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6783 ] 6784 6785 [[package]] ··· 6957 "js-sys", 6958 "wasm-bindgen", 6959 ] 0 0 0 0 0 0 6960 6961 [[package]] 6962 name = "vcpkg"

··· 3064 3065 [[package]] 3066 name = "log" 3067 + version = "0.4.28" 3068 source = "registry+https://github.com/rust-lang/crates.io-index" 3069 + checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" 3070 3071 [[package]] 3072 name = "lru-slab" ··· 3225 checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4" 3226 dependencies = [ 3227 "winapi", 3228 + ] 3229 + 3230 + [[package]] 3231 + name = "nu-ansi-term" 3232 + version = "0.50.1" 3233 + source = "registry+https://github.com/rust-lang/crates.io-index" 3234 + checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399" 3235 + dependencies = [ 3236 + "windows-sys 0.52.0", 3237 ] 3238 3239 [[package]] ··· 3411 3412 [[package]] 3413 name = "owo-colors" 3414 + version = "4.2.2" 3415 source = "registry+https://github.com/rust-lang/crates.io-index" 3416 + checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e" 3417 dependencies = [ 3418 "supports-color 2.1.0", 3419 "supports-color 3.0.2", ··· 4846 "sqlx", 4847 "tokio", 4848 "tokio-stream", 4849 + "tracing", 4850 ] 4851 4852 [[package]] ··· 4898 "tempfile", 4899 "tokio", 4900 "tokio-stream", 4901 + "tracing", 4902 ] 4903 4904 [[package]] ··· 4930 "tempfile", 4931 "tokio", 4932 "tokio-stream", 4933 + "tracing", 4934 ] 4935 4936 [[package]] ··· 4953 "tokio", 4954 "tokio-stream", 4955 "tokio-tungstenite", 4956 + "tracing", 4957 "tungstenite", 4958 "url", 4959 ] ··· 4981 "sqlx", 4982 "tokio", 4983 "tokio-stream", 4984 + "tracing", 4985 ] 4986 4987 [[package]] ··· 5009 "sqlx", 5010 "tokio", 5011 "tokio-stream", 5012 + "tracing", 5013 "uuid", 5014 ] 5015 ··· 5033 "sqlx", 5034 "tokio", 5035 "tokio-stream", 5036 + "tracing", 5037 ] 5038 5039 [[package]] ··· 5050 "sqlx", 5051 "tokio", 5052 "tokio-stream", 5053 + "tracing", 5054 ] 5055 5056 [[package]] ··· 5070 "serde_json", 5071 "tokio", 5072 "tokio-stream", 5073 + "tracing", 5074 "uuid", 5075 ] 5076 ··· 5098 "sqlx", 5099 "tokio", 5100 "tokio-stream", 5101 + "tracing", 5102 ] 5103 5104 [[package]] ··· 5108 "anyhow", 5109 "clap", 5110 "dotenv", 5111 + "owo-colors", 5112 "rocksky-analytics", 5113 "rocksky-dropbox", 5114 "rocksky-googledrive", ··· 5119 "rocksky-tracklist", 5120 "rocksky-webscrobbler", 5121 "tokio", 5122 + "tracing", 5123 + "tracing-log", 5124 + "tracing-subscriber", 5125 ] 5126 5127 [[package]] ··· 5651 "hex", 5652 "sha2", 5653 "tokio", 5654 + ] 5655 + 5656 + [[package]] 5657 + name = "sharded-slab" 5658 + version = "0.1.7" 5659 + source = "registry+https://github.com/rust-lang/crates.io-index" 5660 + checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" 5661 + dependencies = [ 5662 + "lazy_static", 5663 ] 5664 5665 [[package]] ··· 6473 ] 6474 6475 [[package]] 6476 + name = "thread_local" 6477 + version = "1.1.9" 6478 + source = "registry+https://github.com/rust-lang/crates.io-index" 6479 + checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" 6480 + dependencies = [ 6481 + "cfg-if", 6482 + ] 6483 + 6484 + [[package]] 6485 name = "time" 6486 version = "0.3.44" 6487 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 6821 checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" 6822 dependencies = [ 6823 "once_cell", 6824 + "valuable", 6825 + ] 6826 + 6827 + [[package]] 6828 + name = "tracing-log" 6829 + version = "0.2.0" 6830 + source = "registry+https://github.com/rust-lang/crates.io-index" 6831 + checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" 6832 + dependencies = [ 6833 + "log", 6834 + "once_cell", 6835 + "tracing-core", 6836 + ] 6837 + 6838 + [[package]] 6839 + name = "tracing-subscriber" 6840 + version = "0.3.20" 6841 + source = "registry+https://github.com/rust-lang/crates.io-index" 6842 + checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5" 6843 + dependencies = [ 6844 + "nu-ansi-term", 6845 + "sharded-slab", 6846 + "smallvec", 6847 + "thread_local", 6848 + "tracing-core", 6849 + "tracing-log", 6850 ] 6851 6852 [[package]] ··· 7024 "js-sys", 7025 "wasm-bindgen", 7026 ] 7027 + 7028 + [[package]] 7029 + name = "valuable" 7030 + version = "0.1.1" 7031 + source = "registry+https://github.com/rust-lang/crates.io-index" 7032 + checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" 7033 7034 [[package]] 7035 name = "vcpkg"

+1

crates/analytics/Cargo.toml

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

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

+2 -2

crates/analytics/src/cmd/serve.rs

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

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

+37 -84

crates/analytics/src/core.rs

··· 194 .await?; 195 196 for (i, track) in tracks.clone().into_iter().enumerate() { 197 - println!( 198 - "track {} - {} - {}", 199 - i, 200 - track.title.bright_green(), 201 - track.artist 202 - ); 203 match conn.execute( 204 "INSERT INTO tracks ( 205 id, ··· 255 ], 256 ) { 257 Ok(_) => (), 258 - Err(e) => println!("error: {}", e), 259 } 260 } 261 262 - println!("tracks: {:?}", tracks.len()); 263 Ok(()) 264 } 265 ··· 277 .await?; 278 279 for (i, artist) in artists.clone().into_iter().enumerate() { 280 - println!("artist {} - {}", i, artist.name.bright_green()); 281 match conn.execute( 282 "INSERT INTO artists ( 283 id, ··· 323 ], 324 ) { 325 Ok(_) => (), 326 - Err(e) => println!("error: {}", e), 327 } 328 } 329 330 - println!("artists: {:?}", artists.len()); 331 Ok(()) 332 } 333 ··· 342 .await?; 343 344 for (i, album) in albums.clone().into_iter().enumerate() { 345 - println!("album {} - {}", i, album.title.bright_green()); 346 match conn.execute( 347 "INSERT INTO albums ( 348 id, ··· 388 ], 389 ) { 390 Ok(_) => (), 391 - Err(e) => println!("error: {}", e), 392 } 393 } 394 395 - println!("albums: {:?}", albums.len()); 396 Ok(()) 397 } 398 ··· 407 .await?; 408 409 for (i, user) in users.clone().into_iter().enumerate() { 410 - println!("user {} - {}", i, user.display_name.bright_green()); 411 match conn.execute( 412 "INSERT INTO users ( 413 id, ··· 429 ], 430 ) { 431 Ok(_) => (), 432 - Err(e) => println!("error: {}", e), 433 } 434 } 435 436 - println!("users: {:?}", users.len()); 437 Ok(()) 438 } 439 ··· 451 .await?; 452 453 for (i, scrobble) in scrobbles.clone().into_iter().enumerate() { 454 - println!( 455 - "scrobble {} - {}", 456 - i, 457 - match scrobble.uri.clone() { 458 - Some(uri) => uri.to_string(), 459 - None => "None".to_string(), 460 - } 461 - .bright_green() 462 - ); 463 match conn.execute( 464 "INSERT INTO scrobbles ( 465 id, ··· 489 ], 490 ) { 491 Ok(_) => (), 492 - Err(e) => println!("error: {}", e), 493 } 494 } 495 496 - println!("scrobbles: {:?}", scrobbles.len()); 497 Ok(()) 498 } 499 ··· 511 .await?; 512 513 for (i, album_track) in album_tracks.clone().into_iter().enumerate() { 514 - println!( 515 - "album_track {} - {} - {}", 516 - i, 517 - album_track.album_id.bright_green(), 518 - album_track.track_id 519 - ); 520 match conn.execute( 521 "INSERT INTO album_tracks ( 522 id, ··· 532 ], 533 ) { 534 Ok(_) => (), 535 - Err(e) => println!("error: {}", e), 536 } 537 } 538 - println!("album_tracks: {:?}", album_tracks.len()); 0 539 Ok(()) 540 } 541 ··· 553 .await?; 554 555 for (i, loved_track) in loved_tracks.clone().into_iter().enumerate() { 556 - println!( 557 - "loved_track {} - {} - {}", 558 - i, 559 - loved_track.user_id.bright_green(), 560 - loved_track.track_id 561 - ); 562 match conn.execute( 563 "INSERT INTO loved_tracks ( 564 id, ··· 577 ], 578 ) { 579 Ok(_) => (), 580 - Err(e) => println!("error: {}", e), 581 } 582 } 583 584 - println!("loved_tracks: {:?}", loved_tracks.len()); 585 Ok(()) 586 } 587 ··· 599 .await?; 600 601 for (i, artist_track) in artist_tracks.clone().into_iter().enumerate() { 602 - println!( 603 - "artist_track {} - {} - {}", 604 - i, 605 - artist_track.artist_id.bright_green(), 606 - artist_track.track_id 607 - ); 608 match conn.execute( 609 "INSERT INTO artist_tracks (id, artist_id, track_id, created_at) VALUES (?, ?, ?, ?)", 610 params![ ··· 615 ], 616 ) { 617 Ok(_) => (), 618 - Err(e) => println!("error: {}", e), 619 } 620 } 621 622 - println!("artist_tracks: {:?}", artist_tracks.len()); 623 Ok(()) 624 } 625 ··· 637 .await?; 638 639 for (i, artist_album) in artist_albums.clone().into_iter().enumerate() { 640 - println!( 641 - "artist_albums {} - {} - {}", 642 - i, 643 - artist_album.artist_id.bright_green(), 644 - artist_album.album_id 645 - ); 646 match conn.execute( 647 "INSERT INTO artist_albums (id, artist_id, album_id, created_at) VALUES (?, ?, ?, ?)", 648 params![ ··· 653 ], 654 ) { 655 Ok(_) => (), 656 - Err(e) => println!("error: {}", e), 657 } 658 } 659 660 - println!("artist_albums: {:?}", artist_albums.len()); 661 Ok(()) 662 } 663 ··· 675 .await?; 676 677 for (i, user_album) in user_albums.clone().into_iter().enumerate() { 678 - println!( 679 - "user_album {} - {} - {}", 680 - i, 681 - user_album.user_id.bright_green(), 682 - user_album.album_id 683 - ); 684 match conn.execute( 685 "INSERT INTO user_albums (id, user_id, album_id, created_at) VALUES (?, ?, ?, ?)", 686 params![ ··· 691 ], 692 ) { 693 Ok(_) => (), 694 - Err(e) => println!("error: {}", e), 695 } 696 } 697 698 - println!("user_albums: {:?}", user_albums.len()); 699 Ok(()) 700 } 701 ··· 713 .await?; 714 715 for (i, user_artist) in user_artists.clone().into_iter().enumerate() { 716 - println!( 717 - "user_artist {} - {} - {}", 718 - i, 719 - user_artist.user_id.bright_green(), 720 - user_artist.artist_id 721 - ); 722 match conn.execute( 723 "INSERT INTO user_artists (id, user_id, artist_id, created_at) VALUES (?, ?, ?, ?)", 724 params![ ··· 729 ], 730 ) { 731 Ok(_) => (), 732 - Err(e) => println!("error: {}", e), 733 } 734 } 735 736 - println!("user_artists: {:?}", user_artists.len()); 737 Ok(()) 738 } 739 ··· 751 .await?; 752 753 for (i, user_track) in user_tracks.clone().into_iter().enumerate() { 754 - println!( 755 - "user_track {} - {} - {}", 756 - i, 757 - user_track.user_id.bright_green(), 758 - user_track.track_id 759 - ); 760 match conn.execute( 761 "INSERT INTO user_tracks (id, user_id, track_id, created_at) VALUES (?, ?, ?, ?)", 762 params![ ··· 767 ], 768 ) { 769 Ok(_) => (), 770 - Err(e) => println!("error: {}", e), 771 } 772 } 773 774 - println!("user_tracks: {:?}", user_tracks.len()); 775 Ok(()) 776 }

··· 194 .await?; 195 196 for (i, track) in tracks.clone().into_iter().enumerate() { 197 + tracing::info!(track = i, title = %track.title.bright_green(), artist = %track.artist); 0 0 0 0 0 198 match conn.execute( 199 "INSERT INTO tracks ( 200 id, ··· 250 ], 251 ) { 252 Ok(_) => (), 253 + Err(e) => tracing::error!(error = %e, "Error inserting track"), 254 } 255 } 256 257 + tracing::info!(tracks = tracks.len(), "Loaded tracks"); 258 Ok(()) 259 } 260 ··· 272 .await?; 273 274 for (i, artist) in artists.clone().into_iter().enumerate() { 275 + tracing::info!(artist = i, name = %artist.name.bright_green()); 276 match conn.execute( 277 "INSERT INTO artists ( 278 id, ··· 318 ], 319 ) { 320 Ok(_) => (), 321 + Err(e) => tracing::error!(error = %e, "Error inserting artist"), 322 } 323 } 324 325 + tracing::info!(artists = artists.len(), "Loaded artists"); 326 Ok(()) 327 } 328 ··· 337 .await?; 338 339 for (i, album) in albums.clone().into_iter().enumerate() { 340 + tracing::info!(album = i, title = %album.title.bright_green(), artist = %album.artist); 341 match conn.execute( 342 "INSERT INTO albums ( 343 id, ··· 383 ], 384 ) { 385 Ok(_) => (), 386 + Err(e) => tracing::error!(error = %e, "Error inserting album"), 387 } 388 } 389 390 + tracing::info!(albums = albums.len(), "Loaded albums"); 391 Ok(()) 392 } 393 ··· 402 .await?; 403 404 for (i, user) in users.clone().into_iter().enumerate() { 405 + tracing::info!(user = i, name = %user.display_name.bright_green()); 406 match conn.execute( 407 "INSERT INTO users ( 408 id, ··· 424 ], 425 ) { 426 Ok(_) => (), 427 + Err(e) => tracing::error!(error = %e, "Error inserting user"), 428 } 429 } 430 431 + tracing::info!(users = users.len(), "Loaded users"); 432 Ok(()) 433 } 434 ··· 446 .await?; 447 448 for (i, scrobble) in scrobbles.clone().into_iter().enumerate() { 449 + tracing::info!(scrobble = i, uri = %scrobble.uri.clone().unwrap_or_else(|| "None".to_string()).bright_green()); 0 0 0 0 0 0 0 0 450 match conn.execute( 451 "INSERT INTO scrobbles ( 452 id, ··· 476 ], 477 ) { 478 Ok(_) => (), 479 + Err(e) => tracing::error!(error = %e, "Error inserting scrobble"), 480 } 481 } 482 483 + tracing::info!(scrobbles = scrobbles.len(), "Loaded scrobbles"); 484 Ok(()) 485 } 486 ··· 498 .await?; 499 500 for (i, album_track) in album_tracks.clone().into_iter().enumerate() { 501 + tracing::info!(album_track = i, album_id = %album_track.album_id.bright_green(), track_id = %album_track.track_id); 0 0 0 0 0 502 match conn.execute( 503 "INSERT INTO album_tracks ( 504 id, ··· 514 ], 515 ) { 516 Ok(_) => (), 517 + Err(e) => tracing::error!(error = %e, "Error inserting album_track"), 518 } 519 } 520 + 521 + tracing::info!(album_tracks = album_tracks.len(), "Loaded album_tracks"); 522 Ok(()) 523 } 524 ··· 536 .await?; 537 538 for (i, loved_track) in loved_tracks.clone().into_iter().enumerate() { 539 + tracing::info!(loved_track = i, user_id = %loved_track.user_id.bright_green(), track_id = %loved_track.track_id); 0 0 0 0 0 540 match conn.execute( 541 "INSERT INTO loved_tracks ( 542 id, ··· 555 ], 556 ) { 557 Ok(_) => (), 558 + Err(e) => tracing::error!(error = %e, "Error inserting loved_track"), 559 } 560 } 561 562 + tracing::info!(loved_tracks = loved_tracks.len(), "Loaded loved_tracks"); 563 Ok(()) 564 } 565 ··· 577 .await?; 578 579 for (i, artist_track) in artist_tracks.clone().into_iter().enumerate() { 580 + tracing::info!(artist_track = i, artist_id = %artist_track.artist_id.bright_green(), track_id = %artist_track.track_id); 0 0 0 0 0 581 match conn.execute( 582 "INSERT INTO artist_tracks (id, artist_id, track_id, created_at) VALUES (?, ?, ?, ?)", 583 params![ ··· 588 ], 589 ) { 590 Ok(_) => (), 591 + Err(e) => tracing::error!(error = %e, "Error inserting artist_track"), 592 } 593 } 594 595 + tracing::info!(artist_tracks = artist_tracks.len(), "Loaded artist_tracks"); 596 Ok(()) 597 } 598 ··· 610 .await?; 611 612 for (i, artist_album) in artist_albums.clone().into_iter().enumerate() { 613 + tracing::info!(artist_album = i, artist_id = %artist_album.artist_id.bright_green(), album_id = %artist_album.album_id); 0 0 0 0 0 614 match conn.execute( 615 "INSERT INTO artist_albums (id, artist_id, album_id, created_at) VALUES (?, ?, ?, ?)", 616 params![ ··· 621 ], 622 ) { 623 Ok(_) => (), 624 + Err(e) => tracing::error!(error = %e, "Error inserting artist_album"), 625 } 626 } 627 628 + tracing::info!(artist_albums = artist_albums.len(), "Loaded artist_albums"); 629 Ok(()) 630 } 631 ··· 643 .await?; 644 645 for (i, user_album) in user_albums.clone().into_iter().enumerate() { 646 + tracing::info!(user_album = i, user_id = %user_album.user_id.bright_green(), album_id = %user_album.album_id); 0 0 0 0 0 647 match conn.execute( 648 "INSERT INTO user_albums (id, user_id, album_id, created_at) VALUES (?, ?, ?, ?)", 649 params![ ··· 654 ], 655 ) { 656 Ok(_) => (), 657 + Err(e) => tracing::error!(error = %e, "Error inserting user_album"), 658 } 659 } 660 661 + tracing::info!(user_albums = user_albums.len(), "Loaded user_albums"); 662 Ok(()) 663 } 664 ··· 676 .await?; 677 678 for (i, user_artist) in user_artists.clone().into_iter().enumerate() { 679 + tracing::info!(user_artist = i, user_id = %user_artist.user_id.bright_green(), artist_id = %user_artist.artist_id); 0 0 0 0 0 680 match conn.execute( 681 "INSERT INTO user_artists (id, user_id, artist_id, created_at) VALUES (?, ?, ?, ?)", 682 params![ ··· 687 ], 688 ) { 689 Ok(_) => (), 690 + Err(e) => tracing::error!(error = %e, "Error inserting user_artist"), 691 } 692 } 693 694 + tracing::info!(user_artists = user_artists.len(), "Loaded user_artists"); 695 Ok(()) 696 } 697 ··· 709 .await?; 710 711 for (i, user_track) in user_tracks.clone().into_iter().enumerate() { 712 + tracing::info!(user_track = i, user_id = %user_track.user_id.bright_green(), track_id = %user_track.track_id); 0 0 0 0 0 713 match conn.execute( 714 "INSERT INTO user_tracks (id, user_id, track_id, created_at) VALUES (?, ?, ?, ?)", 715 params![ ··· 720 ], 721 ) { 722 Ok(_) => (), 723 + Err(e) => tracing::error!(error = %e, "Error inserting user_track"), 724 } 725 } 726 727 + tracing::info!(user_tracks = user_tracks.len(), "Loaded user_tracks"); 728 Ok(()) 729 }

+4

crates/analytics/src/handlers/albums.rs

··· 22 let offset = pagination.skip.unwrap_or(0); 23 let limit = pagination.take.unwrap_or(20); 24 let did = params.user_did; 0 25 26 let conn = conn.lock().unwrap(); 27 let mut stmt = match did { ··· 118 let offset = pagination.skip.unwrap_or(0); 119 let limit = pagination.take.unwrap_or(20); 120 let did = params.user_did; 0 121 122 let conn = conn.lock().unwrap(); 123 let mut stmt = match did { ··· 237 let body = read_payload!(payload); 238 let params = serde_json::from_slice::<GetAlbumTracksParams>(&body)?; 239 let conn = conn.lock().unwrap(); 0 0 240 let mut stmt = conn.prepare(r#" 241 SELECT 242 t.id,

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

+2

crates/analytics/src/handlers/artists.rs

··· 318 let body = read_payload!(payload); 319 let params = serde_json::from_slice::<GetArtistAlbumsParams>(&body)?; 320 let conn = conn.lock().unwrap(); 0 321 322 let mut stmt = conn.prepare(r#" 323 SELECT ··· 376 let pagination = params.pagination.unwrap_or_default(); 377 let offset = pagination.skip.unwrap_or(0); 378 let limit = pagination.take.unwrap_or(10); 0 379 380 let conn = conn.lock().unwrap(); 381 let mut stmt =

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

+2

crates/analytics/src/handlers/scrobbles.rs

··· 19 let offset = pagination.skip.unwrap_or(0); 20 let limit = pagination.take.unwrap_or(20); 21 let did = params.user_did; 0 22 23 let conn = conn.lock().unwrap(); 24 let mut stmt = match did { ··· 139 let pagination = params.pagination.unwrap_or_default(); 140 let offset = pagination.skip.unwrap_or(0); 141 let limit = pagination.take.unwrap_or(10); 0 142 143 let conn = conn.lock().unwrap(); 144 let mut stmt = conn.prepare(

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

+8

crates/analytics/src/handlers/stats.rs

··· 23 let body = read_payload!(payload); 24 25 let params = serde_json::from_slice::<GetStatsParams>(&body)?; 0 26 27 let conn = conn.lock().unwrap(); 28 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 .end 119 .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 120 let did = params.user_did; 0 121 122 let conn = conn.lock().unwrap(); 123 match did { ··· 190 .end 191 .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 192 let did = params.user_did; 0 193 194 let conn = conn.lock().unwrap(); 195 match did { ··· 266 .end 267 .unwrap_or(GetScrobblesPerDayParams::default().end.unwrap()); 268 let did = params.user_did; 0 269 270 let conn = conn.lock().unwrap(); 271 match did { ··· 338 .end 339 .unwrap_or(GetAlbumScrobblesParams::default().end.unwrap()); 340 let conn = conn.lock().unwrap(); 0 0 341 let mut stmt = conn.prepare( 342 r#" 343 SELECT ··· 379 .end 380 .unwrap_or(GetArtistScrobblesParams::default().end.unwrap()); 381 let conn = conn.lock().unwrap(); 0 382 383 let mut stmt = conn.prepare( 384 r#" ··· 426 .end 427 .unwrap_or(GetTrackScrobblesParams::default().end.unwrap()); 428 let conn = conn.lock().unwrap(); 0 429 430 let mut stmt = conn.prepare( 431 r#"

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

+3

crates/analytics/src/handlers/tracks.rs

··· 19 let offset = pagination.skip.unwrap_or(0); 20 let limit = pagination.take.unwrap_or(20); 21 let did = params.user_did; 0 22 23 let conn = conn.lock().unwrap(); 24 match did { ··· 178 let offset = pagination.skip.unwrap_or(0); 179 let limit = pagination.take.unwrap_or(20); 180 let did = params.user_did; 0 181 182 let conn = conn.lock().unwrap(); 183 let mut stmt = conn.prepare( ··· 261 let offset = pagination.skip.unwrap_or(0); 262 let limit = pagination.take.unwrap_or(20); 263 let did = params.user_did; 0 264 265 let conn = conn.lock().unwrap(); 266 match did {

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

+7 -7

crates/analytics/src/subscriber/mod.rs

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

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

+1

crates/dropbox/Cargo.toml

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

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

+1

crates/googledrive/Cargo.toml

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

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

+1

crates/jetstream/Cargo.toml

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

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

+1

crates/playlists/Cargo.toml

··· 37 hex = "0.4.3" 38 jsonwebtoken = "9.3.1" 39 sha2 = "0.10.8" 0

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

+4

crates/rockskyd/Cargo.toml

··· 20 rocksky-spotify = { path = "../spotify" } 21 rocksky-tracklist = { path = "../tracklist" } 22 rocksky-webscrobbler = { path = "../webscrobbler" } 0 0 0 0

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

+12

crates/rockskyd/src/main.rs

··· 1 use clap::Command; 2 use dotenv::dotenv; 0 3 4 pub mod cmd; 5 ··· 35 36 #[tokio::main] 37 async fn main() -> Result<(), Box<dyn std::error::Error>> { 0 0 0 0 0 0 0 0 0 0 0 38 dotenv().ok(); 39 40 let args = cli().get_matches();

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

+1

crates/scrobbler/Cargo.toml

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

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

+1

crates/spotify/Cargo.toml

··· 38 ] } 39 tokio = { version = "1.43.0", features = ["full"] } 40 tokio-stream = { version = "0.1.17", features = ["full"] } 0

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

+1

crates/storage/Cargo.toml

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

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

+1

crates/tracklist/Cargo.toml

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

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

+1

crates/webscrobbler/Cargo.toml

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

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