style: use inline format args for improved readability

Replace format!("{}", var) with format!("{var}") in cache, backend,
server, and cli crates. This follows the Rust 2021 edition style.

Author: refcell

crates/backend/src/http.rs

@@ -84,7 +84,7 @@ impl HttpBackend {
         response
             .json()
             .await
-            .map_err(|e| RoxyError::Internal(format!("failed to parse response: {}", e)))
+            .map_err(|e| RoxyError::Internal(format!("failed to parse response: {e}")))
     }
 }
 

crates/cache/src/compressed.rs

@@ -27,6 +27,7 @@ pub struct CompressedCache<C> {
 
 impl<C: Cache> CompressedCache<C> {
     /// Create a new compressed cache with default compression quality.
+    #[must_use]
     pub fn new(inner: C) -> Self {
         Self::with_quality(inner, DEFAULT_QUALITY)
     }
@@ -36,6 +37,7 @@ impl<C: Cache> CompressedCache<C> {
     /// # Arguments
     /// * `inner` - The inner cache to wrap
     /// * `quality` - Brotli compression quality (0-11, where 11 is best compression)
+    #[must_use]
     pub fn with_quality(inner: C, quality: u32) -> Self {
         Self { inner, quality: quality.min(11) }
     }
@@ -50,7 +52,7 @@ impl<C: Cache> CompressedCache<C> {
                 self.quality,
                 DEFAULT_LG_WINDOW_SIZE,
             );
-            writer.write_all(data).map_err(|e| CacheError(format!("compression failed: {}", e)))?;
+            writer.write_all(data).map_err(|e| CacheError(format!("compression failed: {e}")))?;
         }
         Ok(compressed)
     }
@@ -61,7 +63,7 @@ impl<C: Cache> CompressedCache<C> {
         let mut decompressor = brotli::Decompressor::new(data, 4096);
         decompressor
             .read_to_end(&mut decompressed)
-            .map_err(|e| CacheError(format!("decompression failed: {}", e)))?;
+            .map_err(|e| CacheError(format!("decompression failed: {e}")))?;
         Ok(decompressed)
     }
 }

crates/cache/src/memory.rs

@@ -40,7 +40,7 @@ impl std::fmt::Debug for MemoryCache {
 impl Cache for MemoryCache {
     async fn get(&self, key: &str) -> Result<Option<Bytes>, CacheError> {
         let mut cache =
-            self.cache.lock().map_err(|e| CacheError(format!("lock poisoned: {}", e)))?;
+            self.cache.lock().map_err(|e| CacheError(format!("lock poisoned: {e}")))?;
 
         if let Some(entry) = cache.get(key) {
             if entry.expires_at > Instant::now() {
@@ -54,7 +54,7 @@ impl Cache for MemoryCache {
 
     async fn put(&self, key: &str, value: Bytes, ttl: Duration) -> Result<(), CacheError> {
         let mut cache =
-            self.cache.lock().map_err(|e| CacheError(format!("lock poisoned: {}", e)))?;
+            self.cache.lock().map_err(|e| CacheError(format!("lock poisoned: {e}")))?;
 
         let entry = CacheEntry { value, expires_at: Instant::now() + ttl };
 
@@ -64,7 +64,7 @@ impl Cache for MemoryCache {
 
     async fn delete(&self, key: &str) -> Result<(), CacheError> {
         let mut cache =
-            self.cache.lock().map_err(|e| CacheError(format!("lock poisoned: {}", e)))?;
+            self.cache.lock().map_err(|e| CacheError(format!("lock poisoned: {e}")))?;
 
         cache.pop(key);
         Ok(())

crates/cache/src/redis.rs

@@ -26,7 +26,7 @@ impl RedisCache {
     /// Returns a `CacheError` if the URL is invalid or connection cannot be established.
     pub fn new(url: &str) -> Result<Self, CacheError> {
         let client =
-            Client::open(url).map_err(|e| CacheError(format!("failed to create client: {}", e)))?;
+            Client::open(url).map_err(|e| CacheError(format!("failed to create client: {e}")))?;
         Ok(Self { client })
     }
 
@@ -35,7 +35,7 @@ impl RedisCache {
         self.client
             .get_multiplexed_async_connection()
             .await
-            .map_err(|e| CacheError(format!("connection error: {}", e)))
+            .map_err(|e| CacheError(format!("connection error: {e}")))
     }
 }
 
@@ -44,7 +44,7 @@ impl Cache for RedisCache {
         let mut conn = self.get_connection().await?;
 
         let result: Option<Vec<u8>> =
-            conn.get(key).await.map_err(|e| CacheError(format!("get error: {}", e)))?;
+            conn.get(key).await.map_err(|e| CacheError(format!("get error: {e}")))?;
 
         Ok(result.map(Bytes::from))
     }
@@ -58,15 +58,15 @@ impl Cache for RedisCache {
         // Use SETEX for atomic set with expiration
         conn.set_ex::<_, _, ()>(key, value.as_ref(), ttl_secs)
             .await
-            .map_err(|e| CacheError(format!("put error: {}", e)))?;
+            .map_err(|e| CacheError(format!("put error: {e}")))?;
 
         Ok(())
     }
 
     async fn delete(&self, key: &str) -> Result<(), CacheError> {
         let mut conn = self.get_connection().await?;
 
-        conn.del::<_, ()>(key).await.map_err(|e| CacheError(format!("delete error: {}", e)))?;
+        conn.del::<_, ()>(key).await.map_err(|e| CacheError(format!("delete error: {e}")))?;
 
         Ok(())
     }

crates/cache/src/rpc_cache.rs

@@ -36,6 +36,7 @@ impl<C: Cache> RpcCache<C> {
     ///
     /// This initializes the cache with sensible default policies for common
     /// Ethereum JSON-RPC methods.
+    #[must_use]
     pub fn new(inner: C) -> Self {
         let mut policies = HashMap::new();
 

crates/cli/src/server.rs

@@ -53,7 +53,7 @@ pub async fn run_server(app: roxy_server::Router, config: &RoxyConfig) -> Result
     let addr = format!("{}:{}", config.server.host, config.server.port);
     let listener = tokio::net::TcpListener::bind(&addr)
         .await
-        .wrap_err_with(|| format!("failed to bind to {}", addr))?;
+        .wrap_err_with(|| format!("failed to bind to {addr}"))?;
 
     info!(address = %addr, "Roxy RPC proxy listening");
 
@@ -63,7 +63,7 @@ pub async fn run_server(app: roxy_server::Router, config: &RoxyConfig) -> Result
         let metrics_addr = format!("{}:{}", config.metrics.host, config.metrics.port);
         let metrics_listener = tokio::net::TcpListener::bind(&metrics_addr)
             .await
-            .wrap_err_with(|| format!("failed to bind metrics server to {}", metrics_addr))?;
+            .wrap_err_with(|| format!("failed to bind metrics server to {metrics_addr}"))?;
 
         info!(address = %metrics_addr, "Metrics server listening");
 

crates/server/src/websocket.rs

@@ -527,7 +527,7 @@ async fn handle_message(
         Ok(req) => req,
         Err(e) => {
             let response =
-                WsResponse::error(serde_json::Value::Null, -32700, format!("Parse error: {}", e));
+                WsResponse::error(serde_json::Value::Null, -32700, format!("Parse error: {e}"));
             return serde_json::to_string(&response).ok();
         }
     };
@@ -579,7 +579,7 @@ async fn handle_subscribe(
             return WsResponse::error(
                 request.id.clone(),
                 -32602,
-                format!("Unknown subscription type: {}", subscription_type),
+                format!("Unknown subscription type: {subscription_type}"),
             );
         }
     }