Fix all remaining clippy uninlined_format_args warnings

- Fixed all 41 clippy warnings across multiple files:
  - src/controller.rs: 7 format string warnings
  - src/graph.rs: 2 format string warnings
  - src/logger.rs: 1 format string warning
  - src/metrics.rs: 9 format string warnings
  - src/throttle.rs: 4 format string warnings
  - src/user.rs: 1 format string warning
  - src/util.rs: 4 format string warnings
  - src/lib.rs: 6 format string warnings

All format strings now use inline format arguments as required by clippy.
The full clippy check now passes: cargo clippy --all-targets --all-features -- -D warnings

Author: jeremyandrews

src/controller.rs

@@ -645,9 +645,9 @@ impl GooseAttack {
                                         } else {
                                             self.configuration.users.unwrap_or_default()
                                         };
-                                info!(
-                                    "changing users from {current_users:?} to {new_users}"
-                                );
+                                        info!(
+                                            "changing users from {current_users:?} to {new_users}"
+                                        );
                                         self.configuration.users = Some(new_users);
                                         self.reply_to_controller(
                                             message,
@@ -901,7 +901,7 @@ impl GooseAttack {
                 }
                 Err(e) => {
                     // Errors can be ignored, they happen any time there are no messages.
-                    debug!("error receiving message: {}", e);
+                    debug!("error receiving message: {e}");
                 }
             }
         };
@@ -955,12 +955,9 @@ pub(crate) async fn controller_main(
     };
 
     // All controllers use a TcpListener port.
-    debug!(
-        "preparing to bind {:?} controller to: {}",
-        protocol, address
-    );
+    debug!("preparing to bind {protocol:?} controller to: {address}");
     let listener = TcpListener::bind(&address).await?;
-    info!("{:?} controller listening on: {}", protocol, address);
+    info!("{protocol:?} controller listening on: {address}");
 
     // Counter increments each time a controller client connects with this protocol.
     let mut thread_id: u32 = 0;
@@ -1277,7 +1274,7 @@ impl ControllerState {
                 let stream = match tokio_tungstenite::accept_async(socket).await {
                     Ok(s) => s,
                     Err(e) => {
-                        info!("invalid WebSocket handshake: {}", e);
+                        info!("invalid WebSocket handshake: {e}");
                         return;
                     }
                 };
@@ -1409,7 +1406,7 @@ impl Controller<ControllerTelnetMessage> for ControllerState {
             Ok(m) => m.lines().next().unwrap_or_default(),
             Err(e) => {
                 let error = format!("ignoring unexpected input from telnet controller: {e}");
-                info!("{}", error);
+                info!("{error}");
                 return Err(error);
             }
         };
@@ -1626,14 +1623,14 @@ impl ControllerExecuteCommand<ControllerWebSocketSender> for ControllerState {
                 }) {
                     Ok(json) => json.into(),
                     Err(e) => {
-                        warn!("failed to json encode response: {}", e);
+                        warn!("failed to json encode response: {e}");
                         return;
                     }
                 },
             ))
             .await
         {
-            info!("failed to write data to websocket: {}", e);
+            info!("failed to write data to websocket: {e}");
         }
     }
 }

src/graph.rs

@@ -96,10 +96,7 @@ impl GraphData {
         let value = self
             .requests_per_second
             .initialize_or_increment(key, second, 1);
-        debug!(
-            "incremented second {} for requests per second counter: {}",
-            second, value
-        );
+        debug!("incremented second {second} for requests per second counter: {value}");
     }
 
     /// Record errors per second metric.
@@ -108,10 +105,7 @@ impl GraphData {
             .errors_per_second
             .initialize_or_increment(key, second, 1);
 
-        debug!(
-            "incremented second {} for errors per second counter: {}",
-            second, value
-        );
+        debug!("incremented second {second} for errors per second counter: {value}");
     }
 
     /// Record average response time per second metric.

src/lib.rs

@@ -666,7 +666,7 @@ impl GooseAttack {
             }
         }
         // 'u' will always be the greatest common divisor
-        debug!("gcd: {}", u);
+        debug!("gcd: {u}");
 
         // Build a vector of vectors to be used to schedule users.
         let mut available_scenarios = Vec::with_capacity(self.scenarios.len());
@@ -706,7 +706,7 @@ impl GooseAttack {
                         .take(scenarios_len)
                     {
                         if let Some(scenario) = scenarios.pop() {
-                            debug!("allocating 1 user from Scenario {}", scenario_index);
+                            debug!("allocating 1 user from Scenario {scenario_index}");
                             weighted_scenarios.push(scenario);
                         }
                     }
@@ -783,7 +783,7 @@ impl GooseAttack {
                 )?);
                 user_count += 1;
                 if user_count == total_users {
-                    debug!("created {} weighted_users", user_count);
+                    debug!("created {user_count} weighted_users");
                     return Ok(weighted_users);
                 }
             }
@@ -1415,7 +1415,7 @@ impl GooseAttack {
                 } else {
                     Duration::from_millis(goose_attack_run_state.adjust_user_in_ms as u64)
                 };
-                debug!("sleeping {:?}...", sleep_duration);
+                debug!("sleeping {sleep_duration:?}...");
                 goose_attack_run_state.drift_timer =
                     util::sleep_minus_drift(sleep_duration, goose_attack_run_state.drift_timer)
                         .await;
@@ -1488,7 +1488,7 @@ impl GooseAttack {
                     .unwrap()
                     .send(None)
                 {
-                    warn!("unexpected error telling logger thread to exit: {}", e);
+                    warn!("unexpected error telling logger thread to exit: {e}");
                 };
                 // Take logger out of the GooseAttackRunState object so it can be
                 // consumed by tokio::join!().
@@ -1604,7 +1604,7 @@ impl GooseAttack {
                 } else {
                     Duration::from_millis(goose_attack_run_state.adjust_user_in_ms as u64)
                 };
-                debug!("sleeping {:?}...", sleep_duration);
+                debug!("sleeping {sleep_duration:?}...");
                 goose_attack_run_state.drift_timer =
                     util::sleep_minus_drift(sleep_duration, goose_attack_run_state.drift_timer)
                         .await;
@@ -1740,7 +1740,7 @@ impl GooseAttack {
                         // Sleep then check for further instructions.
                         if goose_attack_run_state.idle_status_displayed {
                             let sleep_duration = Duration::from_millis(250);
-                            debug!("sleeping {:?}...", sleep_duration);
+                            debug!("sleeping {sleep_duration:?}...");
                             goose_attack_run_state.drift_timer = util::sleep_minus_drift(
                                 sleep_duration,
                                 goose_attack_run_state.drift_timer,
@@ -1853,10 +1853,7 @@ fn allocate_transactions(
     WeightedTransactions,
     WeightedTransactions,
 ) {
-    debug!(
-        "allocating Transactions on GooseUsers with {:?} scheduler",
-        scheduler
-    );
+    debug!("allocating Transactions on GooseUsers with {scheduler:?} scheduler");
 
     // A BTreeMap of Vectors allows us to group and sort transactions per sequence value.
     let mut sequenced_transactions: SequencedTransactions = BTreeMap::new();

src/logger.rs

@@ -735,7 +735,7 @@ impl GooseConfiguration {
         } else {
             match File::create(log_file_path).await {
                 Ok(f) => {
-                    info!("writing {} to: {}", log_file_type, log_file_path);
+                    info!("writing {log_file_type} to: {log_file_path}");
                     Some(BufWriter::with_capacity(buffer_capacity, f))
                 }
                 Err(e) => {

src/metrics.rs

@@ -513,17 +513,17 @@ impl GooseRequestMetricAggregate {
         let counter = match self.status_code_counts.get(&status_code) {
             // We've seen this status code before, increment counter.
             Some(c) => {
-                debug!("got {:?} counter: {}", status_code, c);
+                debug!("got {status_code:?} counter: {c}");
                 *c + 1
             }
             // First time we've seen this status code, initialize counter.
             None => {
-                debug!("no match for counter: {}", status_code);
+                debug!("no match for counter: {status_code}");
                 1
             }
         };
         self.status_code_counts.insert(status_code, counter);
-        debug!("incremented {} counter: {}", status_code, counter);
+        debug!("incremented {status_code} counter: {counter}");
     }
 }
 
@@ -640,16 +640,16 @@ impl GooseRequestMetricTimingData {
         let counter = match self.times.get(&rounded_time) {
             // We've seen this elapsed time before, increment counter.
             Some(c) => {
-                debug!("got {:?} counter: {}", rounded_time, c);
+                debug!("got {rounded_time:?} counter: {c}");
                 *c + 1
             }
             // First time we've seen this elapsed time, initialize counter.
             None => {
-                debug!("no match for counter: {}", rounded_time);
+                debug!("no match for counter: {rounded_time}");
                 1
             }
         };
-        debug!("incremented {} counter: {}", rounded_time, counter);
+        debug!("incremented {rounded_time} counter: {counter}");
         self.times.insert(rounded_time, counter);
     }
 }
@@ -833,7 +833,7 @@ impl TransactionMetricAggregate {
             None => 1,
         };
         self.times.insert(rounded_time, counter);
-        debug!("incremented {} counter: {}", rounded_time, counter);
+        debug!("incremented {rounded_time} counter: {counter}");
     }
 }
 /// Aggregated per-scenario metrics updated each time a scenario is run.
@@ -920,7 +920,7 @@ impl ScenarioMetricAggregate {
             None => 1,
         };
         self.times.insert(rounded_time, counter);
-        debug!("incremented {} counter: {}", rounded_time, counter);
+        debug!("incremented {rounded_time} counter: {counter}");
     }
 }
 /// All metrics optionally collected during a Goose load test.
@@ -2960,9 +2960,9 @@ impl GooseAttack {
                     error: raw_request.error.clone(),
                 }))) {
                     if let flume::SendError(Some(ref message)) = e {
-                        info!("Failed to write to error log (receiver dropped?): flume::SendError({:?})", message);
+                        info!("Failed to write to error log (receiver dropped?): flume::SendError({message:?})");
                     } else {
-                        info!("Failed to write to error log: (receiver dropped?) {:?}", e);
+                        info!("Failed to write to error log: (receiver dropped?) {e:?}");
                     }
                 }
             }
@@ -3408,10 +3408,7 @@ pub(crate) fn calculate_response_time_percentile(
     percent: f32,
 ) -> usize {
     let percentile_request = (total_requests as f32 * percent).round() as usize;
-    debug!(
-        "percentile: {}, request {} of total {}",
-        percent, percentile_request, total_requests
-    );
+    debug!("percentile: {percent}, request {percentile_request} of total {total_requests}");
 
     let mut total_count: usize = 0;
 

src/throttle.rs

@@ -19,10 +19,7 @@ pub async fn throttle_main(
     let tokens_per_duration;
 
     let ten_milliseconds = time::Duration::from_millis(10);
-    debug!(
-        "sleep_duration: {:?} ten_milliseconds: {:?}",
-        sleep_duration, ten_milliseconds
-    );
+    debug!("sleep_duration: {sleep_duration:?} ten_milliseconds: {ten_milliseconds:?}");
 
     // Keep sleep_duration at least ~10ms as `delay_for` has millisecond granularity.
     if sleep_duration < ten_milliseconds {
@@ -32,10 +29,7 @@ pub async fn throttle_main(
         tokens_per_duration = 1;
     }
 
-    info!(
-        "throttle allowing {} request(s) every {:?}",
-        tokens_per_duration, sleep_duration
-    );
+    info!("throttle allowing {tokens_per_duration} request(s) every {sleep_duration:?}");
 
     // One or more token gets removed from the throttle_receiver bucket at regular
     // intervals. The throttle_drift variable tracks how much time is spent on
@@ -44,10 +38,7 @@ pub async fn throttle_main(
 
     // Loop and remove tokens from channel at controlled rate until load test ends.
     loop {
-        debug!(
-            "throttle removing {} token(s) from channel",
-            tokens_per_duration
-        );
+        debug!("throttle removing {tokens_per_duration} token(s) from channel");
         throttle_drift = util::sleep_minus_drift(sleep_duration, throttle_drift).await;
 
         // A message will be received when the load test is over.
@@ -62,7 +53,7 @@ pub async fn throttle_main(
         for token in 0..tokens_per_duration {
             // If the channel is empty, we will get an error, so stop trying to remove tokens.
             if throttle_receiver.try_recv().is_err() {
-                debug!("empty channel, exit after removing {} tokens", token);
+                debug!("empty channel, exit after removing {token} tokens");
                 break;
             }
         }

src/user.rs

@@ -184,7 +184,7 @@ fn received_exit(thread_receiver: &flume::Receiver<GooseUserCommand>) -> bool {
                 return true;
             }
             command => {
-                debug!("ignoring unexpected GooseUserCommand: {:?}", command);
+                debug!("ignoring unexpected GooseUserCommand: {command:?}");
             }
         }
         message = thread_receiver.try_recv();

src/util.rs

@@ -34,7 +34,7 @@ pub fn parse_timespan(time_str: &str) -> usize {
     match usize::from_str(time_str) {
         // If an integer is passed in, assume it's seconds
         Ok(t) => {
-            trace!("{} is integer: {} seconds", time_str, t);
+            trace!("{time_str} is integer: {t} seconds");
             t
         }
         // Otherwise use a regex to extract hours, minutes and seconds from string.
@@ -55,13 +55,7 @@ pub fn parse_timespan(time_str: &str) -> usize {
                 None => 0,
             };
             let total = hours * 60 * 60 + minutes * 60 + seconds;
-            trace!(
-                "{} hours {} minutes {} seconds: {} seconds",
-                hours,
-                minutes,
-                seconds,
-                total
-            );
+            trace!("{hours} hours {minutes} minutes {seconds} seconds: {total} seconds");
             total
         }
     }
@@ -383,7 +377,7 @@ pub fn get_float_from_string(string: Option<String>) -> Option<f32> {
         Some(s) => match s.parse::<f32>() {
             Ok(value) => Some(value),
             Err(e) => {
-                warn!("failed to convert {} to float: {}", s, e);
+                warn!("failed to convert {s} to float: {e}");
                 None
             }
         },
@@ -438,7 +432,7 @@ pub(crate) fn setup_ctrlc_handler() {
             // of the ctrl-c handler.
             let mut canceled = CANCELED.write().unwrap();
             *canceled = false;
-            info!("reset ctrl-c handler: {}", e);
+            info!("reset ctrl-c handler: {e}");
         }
     }
 }