fix new rustc lint warnings

Author: erhant

compute/src/config.rs

@@ -63,7 +63,7 @@ impl DriaComputeNodeConfig {
                 }
             }
             Err(err) => {
-                log::error!("No secret key provided: {}", err);
+                log::error!("No secret key provided: {err}");
                 panic!("Please provide a secret key.");
             }
         };
@@ -81,11 +81,11 @@ impl DriaComputeNodeConfig {
 
         // print address
         let address = hex::encode(public_key_to_address(&public_key));
-        log::info!("Node Address:     0x{}", address);
+        log::info!("Node Address:     0x{address}");
 
         // to this here to log the peer id at start
         let peer_id = secret_to_keypair(&secret_key).public().to_peer_id();
-        log::info!("Node PeerID:      {}", peer_id);
+        log::info!("Node PeerID:      {peer_id}");
 
         // parse listen address
         let p2p_listen_addr_str = env::var("DKN_P2P_LISTEN_ADDR")

compute/src/main.rs

@@ -36,8 +36,8 @@ async fn main() -> Result<()> {
 
     // log about env usage
     match dotenv_result {
-        Ok(_) => log::info!("Loaded environment file from {}", env_path),
-        Err(e) => log::warn!("Could not load environment file from {}: {}", env_path, e),
+        Ok(_) => log::info!("Loaded environment file from {env_path}"),
+        Err(err) => log::warn!("Could not load environment file from {env_path}: {err}"),
     }
 
     // task tracker for multiple threads
@@ -52,14 +52,14 @@ async fn main() -> Result<()> {
             env::var("DKN_EXIT_TIMEOUT").map(|s| s.to_string().parse::<u64>())
         {
             // the timeout is done for profiling only, and should not be used in production
-            log::warn!("Waiting for {} seconds before exiting.", duration_secs);
+            log::warn!("Waiting for {duration_secs} seconds before exiting.");
             tokio::time::sleep(tokio::time::Duration::from_secs(duration_secs)).await;
 
             log::warn!("Exiting due to DKN_EXIT_TIMEOUT.");
             cancellation_token.cancel();
         } else if let Err(err) = wait_for_termination(cancellation_token.clone()).await {
             // if there is no timeout, we wait for termination signals here
-            log::error!("Error waiting for termination: {:?}", err);
+            log::error!("Error waiting for termination: {err:?}");
             log::error!("Cancelling due to unexpected error.");
             cancellation_token.cancel();
         };
@@ -104,7 +104,7 @@ async fn main() -> Result<()> {
             config.executors.get_model_names().join(", "),
             model_perf
                 .iter()
-                .map(|(model, perf)| format!("{}: {}", model, perf))
+                .map(|(model, perf)| format!("{model}: {perf}"))
                 .collect::<Vec<_>>()
                 .join("\n")
         );
@@ -124,10 +124,7 @@ async fn main() -> Result<()> {
             batch_size <= TaskWorker::MAX_BATCH_SIZE,
             "batch size too large"
         );
-        log::info!(
-            "Spawning batch executor worker thread. (batch size {})",
-            batch_size
-        );
+        log::info!("Spawning batch executor worker thread. (batch size {batch_size})");
         task_tracker.spawn(async move { worker_batch.run_batch(batch_size).await });
     }
 

compute/src/node/core.rs

@@ -53,8 +53,8 @@ impl DriaComputeNode {
                 // a task is completed by the worker & should be responded to the requesting peer
                 task_response_msg_opt = self.task_output_rx.recv() => {
                     if let Some(task_response_msg) = task_response_msg_opt {
-                        if let Err(e) = self.send_task_output(task_response_msg).await {
-                            log::error!("Error responding to task: {:?}", e);
+                        if let Err(err) = self.send_task_output(task_response_msg).await {
+                            log::error!("Error responding to task: {err:?}");
                         }
                     } else {
                         log::error!("task_output_rx channel closed unexpectedly, we still have {} batch and {} single tasks.", self.pending_tasks_batch.len(), self.pending_tasks_single.len());
@@ -117,8 +117,8 @@ impl DriaComputeNode {
         self.handle_diagnostic_refresh().await;
 
         // shutdown channels
-        if let Err(e) = self.shutdown().await {
-            log::error!("Could not shutdown the node gracefully: {:?}", e);
+        if let Err(err) = self.shutdown().await {
+            log::error!("Could not shutdown the node gracefully: {err:?}");
         }
     }
 

compute/src/node/mod.rs

@@ -81,7 +81,7 @@ impl DriaComputeNode {
 
         // dial the RPC node
         let dria_rpc = if let Some(addr) = config.initial_rpc_addr.take() {
-            log::info!("Using initial RPC address: {}", addr);
+            log::info!("Using initial RPC address: {addr}");
             DriaRPC::new(addr, config.network).expect("could not get RPC to connect to")
         } else {
             DriaRPC::new_for_network(config.network, &config.version)
@@ -92,7 +92,7 @@ impl DriaComputeNode {
         // we are using the major.minor version as the P2P version
         // so that patch versions do not interfere with the protocol
         let protocol = DriaP2PProtocol::new_major_minor(config.network.protocol_name());
-        log::info!("Using identity: {}", protocol);
+        log::info!("Using identity: {protocol}");
 
         // create p2p client
         let (p2p_client, p2p_commander, request_rx) = DriaP2PClient::new(

compute/src/node/reqres.rs

@@ -30,24 +30,24 @@ impl DriaComputeNode {
                 request_id,
                 channel,
             } => {
-                log::debug!("Received a request ({}) from {}", request_id, peer_id);
+                log::debug!("Received a request ({request_id}) from {peer_id}");
 
                 // ensure that message is from the known RPCs
                 if self.dria_rpc.peer_id != peer_id {
-                    log::warn!("Received request from unauthorized source: {}", peer_id);
+                    log::warn!("Received request from unauthorized source: {peer_id}");
                     log::debug!("Allowed source: {}", self.dria_rpc.peer_id);
-                } else if let Err(e) = self.handle_request(peer_id, &request, channel).await {
-                    log::error!("Error handling request: {:?}", e);
+                } else if let Err(err) = self.handle_request(peer_id, &request, channel).await {
+                    log::error!("Error handling request: {err:?}");
                 }
             }
 
             DriaReqResMessage::Response {
                 response,
                 request_id,
             } => {
-                log::debug!("Received a response ({}) from {}", request_id, peer_id);
-                if let Err(e) = self.handle_response(peer_id, request_id, response).await {
-                    log::error!("Error handling response: {:?}", e);
+                log::debug!("Received a response ({request_id}) from {peer_id}");
+                if let Err(err) = self.handle_response(peer_id, request_id, response).await {
+                    log::error!("Error handling response: {err:?}");
                 }
             }
         };
@@ -65,7 +65,7 @@ impl DriaComputeNode {
         data: Vec<u8>,
     ) -> Result<()> {
         if peer_id != self.dria_rpc.peer_id {
-            log::warn!("Received response from unauthorized source: {}", peer_id);
+            log::warn!("Received response from unauthorized source: {peer_id}");
             log::debug!("Allowed source: {}", self.dria_rpc.peer_id);
         }
 
@@ -126,7 +126,7 @@ impl DriaComputeNode {
 
         let (task_input, task_metadata) =
             TaskResponder::parse_task_request(self, &task_request, channel).await?;
-        if let Err(e) = match task_input.task.is_batchable() {
+        if let Err(err) = match task_input.task.is_batchable() {
             // this is a batchable task, send it to batch worker
             // and keep track of the task id in pending tasks
             true => match self.task_request_batch_tx {
@@ -149,7 +149,7 @@ impl DriaComputeNode {
                 None => eyre::bail!("Single task received but no worker available."),
             },
         } {
-            log::error!("Could not send task to worker: {:?}", e);
+            log::error!("Could not send task to worker: {err:?}");
         };
 
         Ok(())

compute/src/workers/task.rs

@@ -139,7 +139,7 @@ impl TaskWorker {
             );
             debug_assert!(num_tasks != 0, "number of tasks cant be zero");
 
-            log::info!("Processing {} tasks in batch", num_tasks);
+            log::info!("Processing {num_tasks} tasks in batch");
             let mut batch = tasks.into_iter().map(|b| (b, &self.publish_tx));
             match num_tasks {
                 1 => {
@@ -235,8 +235,8 @@ impl TaskWorker {
             stats: input.stats,
         };
 
-        if let Err(e) = publish_tx.send(output).await {
-            log::error!("Error sending task result: {}", e);
+        if let Err(err) = publish_tx.send(output).await {
+            log::error!("Error sending task result: {err}");
         }
     }
 }

executor/src/executors/ollama.rs

@@ -105,7 +105,7 @@ impl OllamaClient {
                 }
             }
         };
-        log::info!("Found local Ollama models: {:#?}", local_models);
+        log::info!("Found local Ollama models: {local_models:#?}");
 
         // check external models & pull them if available
         // iterate over models and remove bad ones
@@ -114,13 +114,13 @@ impl OllamaClient {
         for model in models.iter() {
             // pull the model if it is not in the local models
             if !local_models.contains(&model.to_string()) {
-                log::warn!("Model {} not found in Ollama", model);
+                log::warn!("Model {model} not found in Ollama");
                 if self.auto_pull {
                     self.try_pull(model)
                         .await
                         .wrap_err("could not pull model")?;
                 } else {
-                    log::error!("Please download missing model with: ollama pull {}", model);
+                    log::error!("Please download missing model with: ollama pull {model}");
                     log::error!("Or, set OLLAMA_AUTO_PULL=true to pull automatically.");
                     eyre::bail!("required model not pulled in Ollama");
                 }
@@ -145,7 +145,7 @@ impl OllamaClient {
         if models.is_empty() {
             log::warn!("No Ollama models passed the performance test! Try using a more powerful machine OR smaller models.");
         } else {
-            log::info!("Ollama checks are finished, using models: {:#?}", models);
+            log::info!("Ollama checks are finished, using models: {models:#?}");
         }
 
         Ok(model_performances)
@@ -155,10 +155,7 @@ impl OllamaClient {
     async fn try_pull(&self, model: &Model) -> Result<ollama_rs::models::pull::PullModelStatus> {
         // TODO: add pull-bar here
         // if auto-pull is enabled, pull the model
-        log::info!(
-            "Downloading missing model {} (this may take a while)",
-            model
-        );
+        log::info!("Downloading missing model {model} (this may take a while)");
         self.ollama_rs_client
             .pull_model(model.to_string(), false)
             .await
@@ -173,10 +170,10 @@ impl OllamaClient {
         const TEST_PROMPT: &str = "Please write a poem about Kapadokya.";
         const WARMUP_PROMPT: &str = "Write a short poem about hedgehogs and squirrels.";
 
-        log::info!("Testing model {}", model);
+        log::info!("Measuring {model}");
 
         // run a dummy generation for warm-up
-        log::debug!("Warming up Ollama for model {}", model);
+        log::debug!("Warming up Ollama for {model}");
         if let Err(err) = self
             .ollama_rs_client
             .generate(GenerationRequest::new(
@@ -185,7 +182,7 @@ impl OllamaClient {
             ))
             .await
         {
-            log::warn!("Ignoring model {model}: {err}");
+            log::warn!("Ignoring {model}: {err}");
             return SpecModelPerformance::ExecutionFailed;
         }
 
@@ -199,7 +196,7 @@ impl OllamaClient {
         )
         .await
         else {
-            log::warn!("Ignoring model {model}: Timed out");
+            log::warn!("Ignoring {model}: Timed out");
             return SpecModelPerformance::Timeout;
         };
 
@@ -211,18 +208,17 @@ impl OllamaClient {
                     * 1_000_000_000f64;
 
                 if tps >= PERFORMANCE_MIN_TPS {
-                    log::info!("Model {model} passed the test with tps: {tps}");
+                    log::info!("{model} passed the test with tps: {tps}");
                     SpecModelPerformance::PassedWithTPS(tps)
                 } else {
                     log::warn!(
-                        "Ignoring model {model}: tps too low ({tps:.3} < {:.3})",
-                        PERFORMANCE_MIN_TPS
+                        "Ignoring {model}: tps too low ({tps:.3} < {PERFORMANCE_MIN_TPS:.3})"
                     );
                     SpecModelPerformance::FailedWithTPS(tps)
                 }
             }
             Err(err) => {
-                log::warn!("Ignoring model {model} due to: {err}");
+                log::warn!("Ignoring {model} due to: {err}");
                 SpecModelPerformance::ExecutionFailed
             }
         }

executor/src/manager.rs

@@ -126,10 +126,7 @@ impl DriaExecutorsManager {
         self.providers.retain(|provider, (_, models)| {
             let ok = !models.is_empty();
             if !ok {
-                log::warn!(
-                    "Provider {} has no models left, removing it from the config.",
-                    provider
-                )
+                log::warn!("Provider {provider} has no models left, removing it from the config.")
             }
             ok
         });

executor/src/models.rs

@@ -58,8 +58,8 @@ impl FromStr for Model {
     /// On failure, returns the original string back as the `Err` value.
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         // serde requires quotes (for JSON)
-        serde_json::from_str::<Self>(&format!("\"{}\"", value))
-            .map_err(|e| format!("Model {} invalid: {}", value, e))
+        serde_json::from_str::<Self>(&format!("\"{value}\""))
+            .map_err(|err| format!("Model {value} invalid: {err}"))
     }
 }
 
@@ -204,8 +204,8 @@ impl FromStr for ModelProvider {
     /// On failure, returns the original string back as the `Err` value.
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         // serde requires quotes (for JSON)
-        serde_json::from_str::<Self>(&format!("\"{}\"", value))
-            .map_err(|e| format!("Model provider {} invalid: {}", value, e))
+        serde_json::from_str::<Self>(&format!("\"{value}\""))
+            .map_err(|err| format!("Model provider {value} invalid: {err}"))
     }
 }