fix: improve logging when last.fm returns an error

server/src/main.rs

···
             interval.tick().await;
             let new_template = match monitor.get_scrobble().await {
                 Ok(template) => template,
-                Err(err) => {
-                    tracing::error!("failed to get data from last.fm: {err:?}");
+                Err(error) => {
+                    tracing::error!(?error, "failed to get data from last.fm");
                     continue;
                 }
             };
···
 
             let data = match new_template.render() {
                 Ok(data) => data,
-                Err(err) => {
-                    tracing::error!("failed to render scrobble: {err:?}");
+                Err(error) => {
+                    tracing::error!(?error, "failed to render scrobble");
                     break;
                 }
             };

server/src/scrobble.rs

···
     pub recent_tracks: RecentTracks,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct Error {
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+pub enum Response {
+    Scrobble(Scrobble),
+    Error(Error),
+}
+
 #[derive(Template, Debug, Clone, PartialEq)]
 #[template(path = "scrobble.html")]
 pub struct ScrobblesTemplate {

server/src/scrobble_monitor.rs

···
     time::{Duration, Instant},
 };
 
+use anyhow::anyhow;
 use reqwest::Client;
 use tokio::sync::RwLock;
 
-use crate::scrobble::{Scrobble, ScrobblesTemplate};
+use crate::scrobble::{Response, Scrobble, ScrobblesTemplate};
 
 #[derive(Debug, Clone)]
 struct CachedScrobble {
···
             ])
             .send()
             .await?;
-        Ok(response.json().await?)
+        let response: Response = response.json().await?;
+        match response {
+            Response::Scrobble(scrobble) => Ok(scrobble),
+            Response::Error(err) => {
+                Err(anyhow!("last.fm responded with an error: {}", err.message))
+            }
+        }
     }
 }