refactor: update to Rust 1.85 and edition 2024, use inline log args

- Update MSRV to 1.85 and Rust edition to 2024.
- Refactor all logging macros to use inline argument formatting.
- Fix import order in main.rs and examples.
- Add async environment variable setter to main.rs as safe facade.

Author: roderickvd

CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- [core] MSRV is now 1.81 (breaking)
+- [core] MSRV is now 1.85 with Rust edition 2024 (breaking)
 - [core] AP connect and handshake have a combined 5 second timeout.
 - [core] `stream_from_cdn` now accepts the URL as `TryInto<Uri>` instead of `CdnUrl` (breaking)
 - [connect] Replaced `has_volume_ctrl` with `disable_volume` in `ConnectConfig` (breaking)

Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "librespot"
 version = "0.6.0-dev"
-rust-version = "1.81"
+rust-version = "1.85"
 authors = ["Librespot Org"]
 license = "MIT"
 description = "An open source client library for Spotify, with support for Spotify Connect"
 keywords = ["spotify"]
 repository = "https://github.com/librespot-org/librespot"
 readme = "README.md"
-edition = "2021"
+edition = "2024"
 
 [workspace]
 
@@ -126,4 +126,4 @@ assets = [
 ]
 
 [workspace.package]
-rust-version = "1.81"
+rust-version = "1.85"

audio/src/fetch/mod.rs

@@ -366,11 +366,11 @@ impl AudioFile {
         bytes_per_second: usize,
     ) -> Result<AudioFile, Error> {
         if let Some(file) = session.cache().and_then(|cache| cache.file(file_id)) {
-            debug!("File {} already in cache", file_id);
+            debug!("File {file_id} already in cache");
             return Ok(AudioFile::Cached(file));
         }
 
-        debug!("Downloading file {}", file_id);
+        debug!("Downloading file {file_id}");
 
         let (complete_tx, complete_rx) = oneshot::channel();
 
@@ -379,14 +379,14 @@ impl AudioFile {
 
         let session_ = session.clone();
         session.spawn(complete_rx.map_ok(move |mut file| {
-            debug!("Downloading file {} complete", file_id);
+            debug!("Downloading file {file_id} complete");
 
             if let Some(cache) = session_.cache() {
                 if let Some(cache_id) = cache.file_path(file_id) {
                     if let Err(e) = cache.save_file(file_id, &mut file) {
-                        error!("Error caching file {} to {:?}: {}", file_id, cache_id, e);
+                        error!("Error caching file {file_id} to {cache_id:?}: {e}");
                     } else {
-                        debug!("File {} cached to {:?}", file_id, cache_id);
+                        debug!("File {file_id} cached to {cache_id:?}");
                     }
                 }
             }
@@ -465,14 +465,11 @@ impl AudioFileStreaming {
             )));
         };
 
-        trace!("Streaming from {}", url);
+        trace!("Streaming from {url}");
 
         let code = response.status();
         if code != StatusCode::PARTIAL_CONTENT {
-            debug!(
-                "Opening audio file expected partial content but got: {}",
-                code
-            );
+            debug!("Opening audio file expected partial content but got: {code}");
             return Err(AudioFileError::StatusCode(code).into());
         }
 

connect/src/spirc.rs

@@ -166,7 +166,7 @@ impl Spirc {
         }
 
         let spirc_id = SPIRC_COUNTER.fetch_add(1, Ordering::AcqRel);
-        debug!("new Spirc[{}]", spirc_id);
+        debug!("new Spirc[{spirc_id}]");
 
         let connect_state = ConnectState::new(config, &session);
 
@@ -446,14 +446,14 @@ impl SpircTask {
                 cluster_update = self.connect_state_update.next() => unwrap! {
                     cluster_update,
                     match |cluster_update| if let Err(e) = self.handle_cluster_update(cluster_update).await {
-                        error!("could not dispatch connect state update: {}", e);
+                        error!("could not dispatch connect state update: {e}");
                     }
                 },
                 // main dealer request handling (dealer expects an answer)
                 request = self.connect_state_command.next() => unwrap! {
                     request,
                     |request| if let Err(e) = self.handle_connect_state_request(request).await {
-                        error!("couldn't handle connect state command: {}", e);
+                        error!("couldn't handle connect state command: {e}");
                     }
                 },
                 // volume request handling is send separately (it's more like a fire forget)
@@ -491,12 +491,12 @@ impl SpircTask {
                 },
                 cmd = async { commands?.recv().await }, if commands.is_some() => if let Some(cmd) = cmd {
                     if let Err(e) = self.handle_command(cmd).await {
-                        debug!("could not dispatch command: {}", e);
+                        debug!("could not dispatch command: {e}");
                     }
                 },
                 event = async { player_events?.recv().await }, if player_events.is_some() => if let Some(event) = event {
                     if let Err(e) = self.handle_player_event(event) {
-                        error!("could not dispatch player event: {}", e);
+                        error!("could not dispatch player event: {e}");
                     }
                 },
                 _ = async { sleep(UPDATE_STATE_DELAY).await }, if self.update_state => {
@@ -606,7 +606,7 @@ impl SpircTask {
     }
 
     async fn handle_command(&mut self, cmd: SpircCommand) -> Result<(), Error> {
-        trace!("Received SpircCommand::{:?}", cmd);
+        trace!("Received SpircCommand::{cmd:?}");
         match cmd {
             SpircCommand::Shutdown => {
                 trace!("Received SpircCommand::Shutdown");
@@ -618,16 +618,15 @@ impl SpircTask {
                 }
             }
             SpircCommand::Activate if !self.connect_state.is_active() => {
-                trace!("Received SpircCommand::{:?}", cmd);
+                trace!("Received SpircCommand::{cmd:?}");
                 self.handle_activate();
                 return self.notify().await;
             }
-            SpircCommand::Activate => warn!(
-                "SpircCommand::{:?} will be ignored while already active",
-                cmd
-            ),
+            SpircCommand::Activate => {
+                warn!("SpircCommand::{cmd:?} will be ignored while already active")
+            }
             _ if !self.connect_state.is_active() => {
-                warn!("SpircCommand::{:?} will be ignored while Not Active", cmd)
+                warn!("SpircCommand::{cmd:?} will be ignored while Not Active")
             }
             SpircCommand::Disconnect { pause } => {
                 if pause {
@@ -787,7 +786,7 @@ impl SpircTask {
     }
 
     async fn handle_connection_id_update(&mut self, connection_id: String) -> Result<(), Error> {
-        trace!("Received connection ID update: {:?}", connection_id);
+        trace!("Received connection ID update: {connection_id:?}");
         self.session.set_connection_id(&connection_id);
 
         let cluster = match self
@@ -837,7 +836,7 @@ impl SpircTask {
     }
 
     fn handle_user_attributes_update(&mut self, update: UserAttributesUpdate) {
-        trace!("Received attributes update: {:#?}", update);
+        trace!("Received attributes update: {update:#?}");
         let attributes: UserAttributes = update
             .pairs
             .iter()
@@ -863,12 +862,7 @@ impl SpircTask {
                 };
                 self.session.set_user_attribute(key, new_value);
 
-                trace!(
-                    "Received attribute mutation, {} was {} is now {}",
-                    key,
-                    old_value,
-                    new_value
-                );
+                trace!("Received attribute mutation, {key} was {old_value} is now {new_value}");
 
                 if key == "filter-explicit-content" && new_value == "1" {
                     self.player
@@ -882,10 +876,7 @@ impl SpircTask {
                     self.add_autoplay_resolving_when_required()
                 }
             } else {
-                trace!(
-                    "Received attribute mutation for {} but key was not found!",
-                    key
-                );
+                trace!("Received attribute mutation for {key} but key was not found!");
             }
         }
     }
@@ -1743,7 +1734,7 @@ impl SpircTask {
     }
 
     fn set_volume(&mut self, volume: u16) {
-        debug!("SpircTask::set_volume({})", volume);
+        debug!("SpircTask::set_volume({volume})");
 
         let old_volume = self.connect_state.device_info().volume;
         let new_volume = volume as u32;

core/src/apresolve.rs

@@ -108,7 +108,7 @@ impl ApResolver {
             if inner.data.is_any_empty() {
                 warn!("Failed to resolve all access points, using fallbacks");
                 if let Some(error) = error {
-                    warn!("Resolve access points error: {}", error);
+                    warn!("Resolve access points error: {error}");
                 }
 
                 let fallback = self.parse_resolve_to_access_points(ApResolveData::fallback());

core/src/audio_key.rs

@@ -70,11 +70,7 @@ impl AudioKeyManager {
                     .map_err(|_| AudioKeyError::Channel)?
             }
             _ => {
-                trace!(
-                    "Did not expect {:?} AES key packet with data {:#?}",
-                    cmd,
-                    data
-                );
+                trace!("Did not expect {cmd:?} AES key packet with data {data:#?}");
                 return Err(AudioKeyError::Packet(cmd as u8).into());
             }
         }

core/src/cache.rs

@@ -141,7 +141,7 @@ impl FsSizeLimiter {
         let list_dir = match fs::read_dir(path) {
             Ok(list_dir) => list_dir,
             Err(e) => {
-                warn!("Could not read directory {:?} in cache dir: {}", path, e);
+                warn!("Could not read directory {path:?} in cache dir: {e}");
                 return;
             }
         };
@@ -150,7 +150,7 @@ impl FsSizeLimiter {
             let entry = match entry {
                 Ok(entry) => entry,
                 Err(e) => {
-                    warn!("Could not directory {:?} in cache dir: {}", path, e);
+                    warn!("Could not directory {path:?} in cache dir: {e}");
                     return;
                 }
             };
@@ -166,7 +166,7 @@ impl FsSizeLimiter {
                             limiter.add(&path, size, access_time);
                         }
                         Err(e) => {
-                            warn!("Could not read file {:?} in cache dir: {}", path, e)
+                            warn!("Could not read file {path:?} in cache dir: {e}")
                         }
                     }
                 }
@@ -213,15 +213,15 @@ impl FsSizeLimiter {
 
             let res = fs::remove_file(&file);
             if let Err(e) = res {
-                warn!("Could not remove file {:?} from cache dir: {}", file, e);
+                warn!("Could not remove file {file:?} from cache dir: {e}");
                 last_error = Some(e);
             } else {
                 count += 1;
             }
         }
 
         if count > 0 {
-            info!("Removed {} cache files.", count);
+            info!("Removed {count} cache files.");
         }
 
         if let Some(err) = last_error {
@@ -317,7 +317,7 @@ impl Cache {
                 // If the file did not exist, the file was probably not written
                 // before. Otherwise, log the error.
                 if e.kind != ErrorKind::NotFound {
-                    warn!("Error reading credentials from cache: {}", e);
+                    warn!("Error reading credentials from cache: {e}");
                 }
                 None
             }
@@ -332,7 +332,7 @@ impl Cache {
             });
 
             if let Err(e) = result {
-                warn!("Cannot save credentials to cache: {}", e)
+                warn!("Cannot save credentials to cache: {e}")
             }
         }
     }
@@ -351,7 +351,7 @@ impl Cache {
             Ok(v) => Some(v),
             Err(e) => {
                 if e.kind != ErrorKind::NotFound {
-                    warn!("Error reading volume from cache: {}", e);
+                    warn!("Error reading volume from cache: {e}");
                 }
                 None
             }
@@ -362,7 +362,7 @@ impl Cache {
         if let Some(ref location) = self.volume_location {
             let result = File::create(location).and_then(|mut file| write!(file, "{volume}"));
             if let Err(e) = result {
-                warn!("Cannot save volume to cache: {}", e);
+                warn!("Cannot save volume to cache: {e}");
             }
         }
     }
@@ -375,7 +375,7 @@ impl Cache {
                 path
             }),
             Err(e) => {
-                warn!("Invalid FileId: {}", e);
+                warn!("Invalid FileId: {e}");
                 None
             }
         }
@@ -387,14 +387,14 @@ impl Cache {
             Ok(file) => {
                 if let Some(limiter) = self.size_limiter.as_deref() {
                     if !limiter.touch(&path) {
-                        error!("limiter could not touch {:?}", path);
+                        error!("limiter could not touch {path:?}");
                     }
                 }
                 Some(file)
             }
             Err(e) => {
                 if e.kind() != io::ErrorKind::NotFound {
-                    warn!("Error reading file from cache: {}", e)
+                    warn!("Error reading file from cache: {e}")
                 }
                 None
             }

core/src/cdn_url.rs

@@ -73,7 +73,7 @@ impl CdnUrl {
 
         let cdn_url = Self { file_id, urls };
 
-        trace!("Resolved CDN storage: {:#?}", cdn_url);
+        trace!("Resolved CDN storage: {cdn_url:#?}");
 
         Ok(cdn_url)
     }

core/src/connection/mod.rs

@@ -186,11 +186,7 @@ pub async fn authenticate(
             Err(error_data.into())
         }
         _ => {
-            trace!(
-                "Did not expect {:?} AES key packet with data {:#?}",
-                cmd,
-                data
-            );
+            trace!("Did not expect {cmd:?} AES key packet with data {data:#?}");
             Err(AuthenticationError::Packet(cmd))
         }
     };