diff --git a/crates/ecstore/src/client/api_put_object.rs b/crates/ecstore/src/client/api_put_object.rs
index 257b0707b..aa068e0c4 100644
--- a/crates/ecstore/src/client/api_put_object.rs
+++ b/crates/ecstore/src/client/api_put_object.rs
@@ -237,10 +237,10 @@ impl PutObjectOptions {
             if is_amz_header(k) || is_standard_header(k) || is_storageclass_header(k) || is_rustfs_header(k) || is_minio_header(k)
             {
                 if let Ok(header_name) = HeaderName::from_bytes(k.as_bytes()) {
-                    header.insert(header_name, HeaderValue::from_str(&v).unwrap());
+                    header.insert(header_name, HeaderValue::from_str(&v).expect("operation should succeed"));
                 }
             } else if let Ok(header_name) = HeaderName::from_bytes(format!("x-amz-meta-{}", k).as_bytes()) {
-                header.insert(header_name, HeaderValue::from_str(&v).unwrap());
+                header.insert(header_name, HeaderValue::from_str(&v).expect("operation should succeed"));
             }
         }
 
@@ -376,7 +376,7 @@ impl TransitionClient {
 
             let mut md5_base64: String = "".to_string();
             if opts.send_content_md5 {
-                if let Some(mut md5_hasher) = self.md5_hasher.lock().unwrap().as_mut() {
+                if let Some(mut md5_hasher) = self.md5_hasher.lock().expect("operation should succeed").as_mut() {
                     let hash = md5_hasher.hash_encode(&buf[..length]);
                     md5_base64 = base64_encode(hash.as_ref());
                 }
diff --git a/crates/ecstore/src/erasure/coding/erasure.rs b/crates/ecstore/src/erasure/coding/erasure.rs
index 1098d4ac6..1d5296b0d 100644
--- a/crates/ecstore/src/erasure/coding/erasure.rs
+++ b/crates/ecstore/src/erasure/coding/erasure.rs
@@ -412,7 +412,7 @@ fn recover_empty_payload_data_shards(
 /// use rustfs_ecstore::api::erasure::Erasure;
 /// let erasure = Erasure::new(4, 2, 8);
 /// let data = b"hello world";
-/// let shards = erasure.encode_data(data).unwrap();
+/// let shards = erasure.encode_data(data).expect("operation should succeed");
 /// // Simulate loss and recovery...
 /// ```
 pub struct Erasure {
@@ -474,13 +474,13 @@ impl Erasure {
     /// for decode/reconstruct (for reading and healing old-version files).
     pub fn new_with_options(data_shards: usize, parity_shards: usize, block_size: usize, uses_legacy: bool) -> Self {
         let encoder = if !uses_legacy && parity_shards > 0 {
-            Some(ReedSolomonEncoder::new(data_shards, parity_shards).unwrap())
+            Some(ReedSolomonEncoder::new(data_shards, parity_shards).expect("operation should succeed"))
         } else {
             None
         };
 
         let legacy_encoder = if uses_legacy && parity_shards > 0 {
-            Some(LegacyReedSolomonEncoder::new(data_shards, parity_shards).unwrap())
+            Some(LegacyReedSolomonEncoder::new(data_shards, parity_shards).expect("operation should succeed"))
         } else {
             None
         };
@@ -1208,7 +1208,7 @@ mod tests {
         let test_data = b"SIMD mode test data for encoding and decoding roundtrip verification with sufficient length to ensure shard size requirements are met for proper SIMD optimization.".repeat(20); // ~3KB for SIMD
 
         let data = &test_data;
-        let encoded_shards = erasure.encode_data(data).unwrap();
+        let encoded_shards = erasure.encode_data(data).expect("operation should succeed");
         assert_eq!(encoded_shards.len(), data_shards + parity_shards);
 
         // Create decode input with some shards missing, convert to the format expected by decode_data
@@ -1217,12 +1217,12 @@ mod tests {
             decode_input[i] = Some(encoded_shards[i].to_vec());
         }
 
-        erasure.decode_data(&mut decode_input).unwrap();
+        erasure.decode_data(&mut decode_input).expect("operation should succeed");
 
         // Recover original data
         let mut recovered = Vec::new();
         for shard in decode_input.iter().take(data_shards) {
-            recovered.extend_from_slice(shard.as_ref().unwrap());
+            recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
         }
         recovered.truncate(data.len());
         assert_eq!(&recovered, data);
@@ -1238,7 +1238,7 @@ mod tests {
         // Generate 1MB test data
         let data: Vec<u8> = (0..1048576).map(|i| (i % 256) as u8).collect();
 
-        let encoded_shards = erasure.encode_data(&data).unwrap();
+        let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
         assert_eq!(encoded_shards.len(), data_shards + parity_shards);
 
         // Create decode input with some shards missing, convert to the format expected by decode_data
@@ -1247,12 +1247,12 @@ mod tests {
             decode_input[i] = Some(encoded_shards[i].to_vec());
         }
 
-        erasure.decode_data(&mut decode_input).unwrap();
+        erasure.decode_data(&mut decode_input).expect("operation should succeed");
 
         // Recover original data
         let mut recovered = Vec::new();
         for shard in decode_input.iter().take(data_shards) {
-            recovered.extend_from_slice(shard.as_ref().unwrap());
+            recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
         }
         recovered.truncate(data.len());
         assert_eq!(recovered, data);
@@ -1265,7 +1265,7 @@ mod tests {
         let block_size = 6;
         let erasure = Erasure::new(data_shards, parity_shards, block_size);
         let data = vec![0u8; block_size];
-        let shards = erasure.encode_data(&data).unwrap();
+        let shards = erasure.encode_data(&data).expect("operation should succeed");
         assert_eq!(shards.len(), data_shards + parity_shards);
         let total_len: usize = shards.iter().map(|b| b.len()).sum();
         assert_eq!(total_len, erasure.shard_size() * (data_shards + parity_shards));
@@ -1296,7 +1296,7 @@ mod tests {
         let erasure = Erasure::new_with_options(data_shards, parity_shards, block_size, true);
 
         let data = b"Legacy encode/decode roundtrip test data with sufficient length.".repeat(20);
-        let encoded_shards = erasure.encode_data(&data).unwrap();
+        let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
         assert_eq!(encoded_shards.len(), data_shards + parity_shards);
 
         let mut decode_input: Vec<Option<Vec<u8>>> = vec![None; data_shards + parity_shards];
@@ -1304,11 +1304,11 @@ mod tests {
             decode_input[i] = Some(encoded_shards[i].to_vec());
         }
 
-        erasure.decode_data(&mut decode_input).unwrap();
+        erasure.decode_data(&mut decode_input).expect("operation should succeed");
 
         let mut recovered = Vec::new();
         for shard in decode_input.iter().take(data_shards) {
-            recovered.extend_from_slice(shard.as_ref().unwrap());
+            recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
         }
         recovered.truncate(data.len());
         assert_eq!(&recovered, &data);
@@ -1322,17 +1322,17 @@ mod tests {
         let erasure = Erasure::new_with_options(data_shards, parity_shards, block_size, true);
 
         let data = b"Legacy decode with missing shards test.".repeat(10);
-        let encoded_shards = erasure.encode_data(&data).unwrap();
+        let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
 
         let mut shards_opt: Vec<Option<Vec<u8>>> = encoded_shards.iter().map(|s| Some(s.to_vec())).collect();
         shards_opt[1] = None;
         shards_opt[5] = None;
 
-        erasure.decode_data(&mut shards_opt).unwrap();
+        erasure.decode_data(&mut shards_opt).expect("operation should succeed");
 
         let mut recovered = Vec::new();
         for shard in shards_opt.iter().take(data_shards) {
-            recovered.extend_from_slice(shard.as_ref().unwrap());
+            recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
         }
         recovered.truncate(data.len());
         assert_eq!(&recovered, &data);
@@ -1373,17 +1373,17 @@ mod tests {
                 .encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
                     let tx = tx.clone();
                     async move {
-                        let shards = res.unwrap();
-                        tx.send(shards).await.unwrap();
+                        let shards = res.expect("operation should succeed");
+                        tx.send(shards).await.expect("operation should succeed");
                         Ok(())
                     }
                 })
                 .await
-                .unwrap();
+                .expect("operation should succeed");
         });
         let result = handle.await;
         assert!(result.is_ok());
-        let collected_shards = rx.recv().await.unwrap();
+        let collected_shards = rx.recv().await.expect("operation should succeed");
         assert_eq!(collected_shards.len(), data_shards + parity_shards);
     }
 
@@ -1412,17 +1412,17 @@ mod tests {
                 .encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
                     let tx = tx.clone();
                     async move {
-                        let shards = res.unwrap();
-                        tx.send(shards).await.unwrap();
+                        let shards = res.expect("operation should succeed");
+                        tx.send(shards).await.expect("operation should succeed");
                         Ok(())
                     }
                 })
                 .await
-                .unwrap();
+                .expect("operation should succeed");
         });
         let result = handle.await;
         assert!(result.is_ok());
-        let shards = rx.recv().await.unwrap();
+        let shards = rx.recv().await.expect("operation should succeed");
         assert_eq!(shards.len(), data_shards + parity_shards);
 
         // Test decode using the old API that operates in-place
@@ -1430,12 +1430,12 @@ mod tests {
         for i in 0..data_shards {
             decode_input[i] = Some(shards[i].to_vec());
         }
-        erasure.decode_data(&mut decode_input).unwrap();
+        erasure.decode_data(&mut decode_input).expect("operation should succeed");
 
         // Recover original data
         let mut recovered = Vec::new();
         for shard in decode_input.iter().take(data_shards) {
-            recovered.extend_from_slice(shard.as_ref().unwrap());
+            recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
         }
         recovered.truncate(data_clone.len());
         assert_eq!(&recovered, &data_clone);
@@ -1456,7 +1456,7 @@ mod tests {
                 let observed = observed_clone.clone();
                 async move {
                     let err = res.expect_err("zero block size should report an error");
-                    *observed.lock().unwrap() = Some((err.kind(), err.to_string()));
+                    *observed.lock().expect("operation should succeed") = Some((err.kind(), err.to_string()));
                     Ok(())
                 }
             })
@@ -1464,7 +1464,7 @@ mod tests {
             .expect("callback should handle the zero block size error");
 
         assert_eq!(total, 0);
-        let observed = observed.lock().unwrap();
+        let observed = observed.lock().expect("operation should succeed");
         let (kind, message) = observed.as_ref().expect("callback should be invoked once");
         assert_eq!(*kind, io::ErrorKind::InvalidInput);
         assert!(message.contains("block_size"));
@@ -1485,7 +1485,7 @@ mod tests {
             let test_data = b"SIMD mode test data for encoding and decoding roundtrip verification with sufficient length to ensure shard size requirements are met for proper SIMD optimization and validation.";
             let data = test_data.repeat(25); // Create much larger data: ~5KB total, ~1.25KB per shard
 
-            let encoded_shards = erasure.encode_data(&data).unwrap();
+            let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
             assert_eq!(encoded_shards.len(), data_shards + parity_shards);
 
             // Create decode input with some shards missing
@@ -1495,12 +1495,12 @@ mod tests {
             shards_opt[1] = None; // Lose second data shard
             shards_opt[5] = None; // Lose second parity shard
 
-            erasure.decode_data(&mut shards_opt).unwrap();
+            erasure.decode_data(&mut shards_opt).expect("operation should succeed");
 
             // Verify recovered data
             let mut recovered = Vec::new();
             for shard in shards_opt.iter().take(data_shards) {
-                recovered.extend_from_slice(shard.as_ref().unwrap());
+                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
             }
             recovered.truncate(data.len());
             assert_eq!(&recovered, &data);
@@ -1516,7 +1516,7 @@ mod tests {
             // Create all-zero data that ensures adequate shard size for SIMD optimization
             let data = vec![0u8; 1024]; // 1KB of zeros, each shard will be 256 bytes
 
-            let encoded_shards = erasure.encode_data(&data).unwrap();
+            let encoded_shards = erasure.encode_data(&data).expect("operation should succeed");
             assert_eq!(encoded_shards.len(), data_shards + parity_shards);
 
             // Verify that all data shards are zeros
@@ -1531,12 +1531,12 @@ mod tests {
             shards_opt[0] = None; // Lose first data shard
             shards_opt[4] = None; // Lose first parity shard
 
-            erasure.decode_data(&mut shards_opt).unwrap();
+            erasure.decode_data(&mut shards_opt).expect("operation should succeed");
 
             // Verify recovered data is still all zeros
             let mut recovered = Vec::new();
             for shard in shards_opt.iter().take(data_shards) {
-                recovered.extend_from_slice(shard.as_ref().unwrap());
+                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
             }
             recovered.truncate(data.len());
             assert!(recovered.iter().all(|&x| x == 0), "Recovered data should be all zeros");
@@ -1555,7 +1555,7 @@ mod tests {
                 data.push((i % 256) as u8);
             }
 
-            let shards = erasure.encode_data(&data).unwrap();
+            let shards = erasure.encode_data(&data).expect("operation should succeed");
             assert_eq!(shards.len(), data_shards + parity_shards);
 
             // Simulate the loss of multiple shards
@@ -1566,12 +1566,12 @@ mod tests {
             shards_opt[11] = None; // Parity shard
 
             // Decode
-            erasure.decode_data(&mut shards_opt).unwrap();
+            erasure.decode_data(&mut shards_opt).expect("operation should succeed");
 
             // Recover original data
             let mut recovered = Vec::new();
             for shard in shards_opt.iter().take(data_shards) {
-                recovered.extend_from_slice(shard.as_ref().unwrap());
+                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
             }
             recovered.truncate(data.len());
             assert_eq!(&recovered, &data);
@@ -1603,7 +1603,7 @@ mod tests {
                         Ok(_) => {
                             let mut recovered = Vec::new();
                             for shard in shards_opt.iter().take(data_shards) {
-                                recovered.extend_from_slice(shard.as_ref().unwrap());
+                                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
                             }
                             recovered.truncate(data.len());
                             assert_eq!(&recovered, &data);
@@ -1630,7 +1630,7 @@ mod tests {
             let data =
                 b"Testing maximum erasure capacity with SIMD Reed-Solomon implementation for robustness verification!".repeat(3);
 
-            let shards = erasure.encode_data(&data).unwrap();
+            let shards = erasure.encode_data(&data).expect("operation should succeed");
 
             // Lose exactly the maximum number of shards (equal to parity_shards)
             let mut shards_opt: Vec<Option<Vec<u8>>> = shards.iter().map(|b| Some(b.to_vec())).collect();
@@ -1639,11 +1639,11 @@ mod tests {
             shards_opt[6] = None; // Parity shard
 
             // Should succeed with maximum erasures
-            erasure.decode_data(&mut shards_opt).unwrap();
+            erasure.decode_data(&mut shards_opt).expect("operation should succeed");
 
             let mut recovered = Vec::new();
             for shard in shards_opt.iter().take(data_shards) {
-                recovered.extend_from_slice(shard.as_ref().unwrap());
+                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
             }
             recovered.truncate(data.len());
             assert_eq!(&recovered, &data);
@@ -1662,7 +1662,7 @@ mod tests {
         fn test_reed_solomon_compat() {
             let data = generate_compat_test_data(7557);
             let erasure = Erasure::new(4, 2, 7557);
-            let shards = erasure.encode_data(&data).unwrap();
+            let shards = erasure.encode_data(&data).expect("operation should succeed");
             assert_eq!(shards.len(), 6, "expected 6 shards (4 data + 2 parity)");
 
             // Per-shard HighwayHash
@@ -1732,7 +1732,7 @@ mod tests {
                             // Verify recovered data
                             let mut recovered = Vec::new();
                             for shard in shards_opt.iter().take(data_shards) {
-                                recovered.extend_from_slice(shard.as_ref().unwrap());
+                                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
                             }
                             recovered.truncate(small_data.len());
                             println!("recovered: {recovered:?}");
@@ -1776,7 +1776,7 @@ mod tests {
 
             // Encode the data
             let start = std::time::Instant::now();
-            let shards = erasure.encode_data(&data).unwrap();
+            let shards = erasure.encode_data(&data).expect("operation should succeed");
             let encode_duration = start.elapsed();
 
             println!("⏱️  Encoding completed in: {encode_duration:?}");
@@ -1800,7 +1800,7 @@ mod tests {
 
             // Decode and recover data
             let start = std::time::Instant::now();
-            erasure.decode_data(&mut shards_opt).unwrap();
+            erasure.decode_data(&mut shards_opt).expect("operation should succeed");
             let decode_duration = start.elapsed();
 
             println!("⏱️  Decoding completed in: {decode_duration:?}");
@@ -1808,7 +1808,7 @@ mod tests {
             // Verify recovered data integrity
             let mut recovered = Vec::new();
             for shard in shards_opt.iter().take(data_shards) {
-                recovered.extend_from_slice(shard.as_ref().unwrap());
+                recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
             }
             recovered.truncate(data.len());
 
@@ -1853,20 +1853,20 @@ mod tests {
                     .encode_stream_callback_async::<_, _, (), _>(&mut reader, move |res| {
                         let tx = tx.clone();
                         async move {
-                            let shards = res.unwrap();
-                            tx.send(shards).await.unwrap();
+                            let shards = res.expect("operation should succeed");
+                            tx.send(shards).await.expect("operation should succeed");
                             Ok(())
                         }
                     })
                     .await
-                    .unwrap();
+                    .expect("operation should succeed");
             });
 
             let mut all_blocks = Vec::new();
             while let Some(block) = rx.recv().await {
                 all_blocks.push(block);
             }
-            handle.await.unwrap();
+            handle.await.expect("operation should succeed");
 
             // Verify we got multiple blocks
             assert!(all_blocks.len() > 1, "Should have multiple blocks for stream test");
@@ -1879,10 +1879,10 @@ mod tests {
                 shards_opt[1] = None;
                 shards_opt[5] = None;
 
-                erasure.decode_data(&mut shards_opt).unwrap();
+                erasure.decode_data(&mut shards_opt).expect("operation should succeed");
 
                 for shard in shards_opt.iter().take(data_shards) {
-                    recovered.extend_from_slice(shard.as_ref().unwrap());
+                    recovered.extend_from_slice(shard.as_ref().expect("operation should succeed"));
                 }
             }
 
diff --git a/crates/ecstore/src/runtime/global.rs b/crates/ecstore/src/runtime/global.rs
index e79cbd096..ab03648ca 100644
--- a/crates/ecstore/src/runtime/global.rs
+++ b/crates/ecstore/src/runtime/global.rs
@@ -112,7 +112,7 @@ pub fn set_global_rustfs_port(value: u16) {
 /// * None
 ///
 pub fn set_global_deployment_id(id: Uuid) {
-    globalDeploymentIDPtr.set(id).unwrap();
+    globalDeploymentIDPtr.set(id).expect("operation should succeed");
 }
 
 /// Get the global deployment id
@@ -274,7 +274,7 @@ pub(crate) type TypeLocalDiskSetDrives = Vec<Vec<Vec<Option<DiskStore>>>>;
 /// # Returns
 /// * None
 pub fn set_global_region(region: s3s::region::Region) {
-    GLOBAL_REGION.set(region).unwrap();
+    GLOBAL_REGION.set(region).expect("operation should succeed");
 }
 
 /// Get the global region
diff --git a/crates/ecstore/src/store/rebalance.rs b/crates/ecstore/src/store/rebalance.rs
index 06eb916d8..726b76e2c 100644
--- a/crates/ecstore/src/store/rebalance.rs
+++ b/crates/ecstore/src/store/rebalance.rs
@@ -36,7 +36,7 @@ impl ECStore {
                 //     if disk.is_none() {
                 //         continue;
                 //     }
-                //     // let disk = disk.as_ref().unwrap().clone();
+                //     // let disk = disk.as_ref().expect("operation should succeed").clone();
                 //     // futures.push(disk.delete(
                 //     //     bucket,
                 //     //     prefix,
@@ -315,7 +315,7 @@ impl ECStore {
                 return Ok((pinfo.clone(), self.pools_with_object(&ress, opts).await));
             }
 
-            let err = pinfo.err.as_ref().unwrap();
+            let err = pinfo.err.as_ref().expect("operation should succeed");
 
             if err == &Error::ErasureReadQuorum && !opts.metadata_chg {
                 return Ok((pinfo.clone(), self.pools_with_object(&ress, opts).await));
@@ -460,7 +460,7 @@ impl ECStore {
 
         let mut pool_meta = self.pool_meta.write().await;
         *pool_meta = meta;
-        // *self.pool_meta.write().unwrap() = meta;
+        // *self.pool_meta.write().expect("operation should succeed") = meta;
         Ok(())
     }
 
@@ -638,7 +638,7 @@ mod tests {
 
     fn object_info_with_mod_time(unix_ts: i64, delete_marker: bool) -> ObjectInfo {
         ObjectInfo {
-            mod_time: Some(OffsetDateTime::from_unix_timestamp(unix_ts).unwrap()),
+            mod_time: Some(OffsetDateTime::from_unix_timestamp(unix_ts).expect("operation should succeed")),
             delete_marker,
             ..Default::default()
         }
@@ -660,7 +660,7 @@ mod tests {
         ];
 
         let (info, idx) =
-            resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).unwrap();
+            resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).expect("operation should succeed");
 
         assert_eq!(idx, 1);
         assert!(info.delete_marker);
@@ -681,7 +681,7 @@ mod tests {
             },
         ];
 
-        let (_, idx) = resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).unwrap();
+        let (_, idx) = resolve_latest_object_info_candidates(candidates, "bucket", "object", &ObjectOptions::default()).expect("operation should succeed");
 
         assert_eq!(idx, 1);
     }
diff --git a/crates/io-core/src/pool.rs b/crates/io-core/src/pool.rs
index ff46e0384..7000a1429 100644
--- a/crates/io-core/src/pool.rs
+++ b/crates/io-core/src/pool.rs
@@ -383,7 +383,7 @@ impl PoolTier {
 
         // Use the pool's shared metrics for recording
         let _metrics_lock = self.metrics.lock().unwrap_or_else(|e| e.into_inner());
-        let _metrics = _metrics_lock.as_ref().unwrap();
+        let _metrics = _metrics_lock.as_ref().expect("operation should succeed");
 
         // Record acquisition
         pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed);
@@ -406,7 +406,7 @@ impl PoolTier {
 
         // Use the pool's shared metrics for recording
         let _metrics_lock = self.metrics.lock().unwrap_or_else(|e| e.into_inner());
-        let _metrics = _metrics_lock.as_ref().unwrap();
+        let _metrics = _metrics_lock.as_ref().expect("operation should succeed");
 
         // Record acquisition
         pool_metrics.total_acquires.fetch_add(1, Ordering::Relaxed);
diff --git a/crates/protocols/src/swift/expiration_worker.rs b/crates/protocols/src/swift/expiration_worker.rs
index e97e26f58..2089b7f40 100644
--- a/crates/protocols/src/swift/expiration_worker.rs
+++ b/crates/protocols/src/swift/expiration_worker.rs
@@ -342,7 +342,7 @@ impl ExpirationWorker {
         metrics: &Arc<RwLock<ExpirationMetrics>>,
     ) -> SwiftResult<()> {
         let start_time = SystemTime::now();
-        let now = start_time.duration_since(UNIX_EPOCH).unwrap().as_secs();
+        let now = start_time.duration_since(UNIX_EPOCH).expect("operation should succeed").as_secs();
 
         debug!(
             event = EVENT_SWIFT_EXPIRATION_ITERATION_SUMMARY,
@@ -375,7 +375,7 @@ impl ExpirationWorker {
                 }
 
                 // Remove from queue and add to batch
-                let entry = queue.pop().unwrap().0;
+                let entry = queue.pop().expect("operation should succeed").0;
                 drop(queue); // Release lock
 
                 batch.push(entry);
@@ -452,7 +452,7 @@ impl ExpirationWorker {
         }
 
         // Update metrics
-        let duration = SystemTime::now().duration_since(start_time).unwrap();
+        let duration = SystemTime::now().duration_since(start_time).expect("operation should succeed");
         let mut m = metrics.write().await;
         m.objects_scanned += scanned_count;
         m.objects_deleted += deleted_count;
@@ -589,9 +589,9 @@ mod tests {
         }));
 
         // Should pop in order: 1000, 2000, 3000
-        assert_eq!(heap.pop().unwrap().0.expires_at, 1000);
-        assert_eq!(heap.pop().unwrap().0.expires_at, 2000);
-        assert_eq!(heap.pop().unwrap().0.expires_at, 3000);
+        assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 1000);
+        assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 2000);
+        assert_eq!(heap.pop().expect("operation should succeed").0.expires_at, 3000);
     }
 
     #[test]
diff --git a/crates/rio/src/encrypt_reader.rs b/crates/rio/src/encrypt_reader.rs
index c39515cd2..1e2c95502 100644
--- a/crates/rio/src/encrypt_reader.rs
+++ b/crates/rio/src/encrypt_reader.rs
@@ -636,7 +636,7 @@ mod tests {
         let reader = BufReader::new(Cursor::new(data.to_vec()));
         let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
         encrypted
     }
 
@@ -674,14 +674,14 @@ mod tests {
         // Encrypt
         let mut encrypt_reader = encrypt_reader;
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         // Decrypt using DecryptReader
         let reader = Cursor::new(encrypted.clone());
         let decrypt_reader = DecryptReader::new(reader, key, nonce);
         let mut decrypt_reader = decrypt_reader;
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         assert_eq!(&decrypted, data);
     }
@@ -700,7 +700,7 @@ mod tests {
         let encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypt_reader = encrypt_reader;
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         // Now test DecryptReader
 
@@ -708,7 +708,7 @@ mod tests {
         let decrypt_reader = DecryptReader::new(reader, key, nonce);
         let mut decrypt_reader = decrypt_reader;
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         assert_eq!(&decrypted, data);
     }
@@ -728,13 +728,13 @@ mod tests {
         let encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypt_reader = encrypt_reader;
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         let reader = std::io::Cursor::new(encrypted.clone());
         let decrypt_reader = DecryptReader::new(reader, key, nonce);
         let mut decrypt_reader = decrypt_reader;
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         assert_eq!(&decrypted, &data);
     }
@@ -752,12 +752,12 @@ mod tests {
         let reader = Cursor::new(data.clone());
         let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         let reader = ChunkedCursor::new(encrypted, 3);
         let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         assert_eq!(decrypted, data);
     }
@@ -775,12 +775,12 @@ mod tests {
         let reader = Cursor::new(data.clone());
         let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         let reader = PendingChunkedCursor::new(encrypted, 3);
         let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         assert_eq!(decrypted, data);
     }
@@ -798,7 +798,7 @@ mod tests {
         let reader = Cursor::new(data.clone());
         let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         let reader = ChunkedCursor::new(encrypted, 8192);
         let decrypt_reader = DecryptReader::new(reader, key, nonce);
@@ -806,7 +806,7 @@ mod tests {
 
         let mut decrypted = Vec::new();
         while let Some(chunk) = stream.next().await {
-            let bytes = chunk.unwrap();
+            let bytes = chunk.expect("operation should succeed");
             decrypted.extend_from_slice(&bytes);
         }
 
@@ -826,7 +826,7 @@ mod tests {
         let reader = Cursor::new(data.clone());
         let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         let reader = ChunkedCursor::new(encrypted, 8192);
         let decrypt_reader = DecryptReader::new(reader, key, nonce);
@@ -835,7 +835,7 @@ mod tests {
 
         let mut decrypted = Vec::new();
         while let Some(chunk) = stream.next().await {
-            let bytes = chunk.unwrap();
+            let bytes = chunk.expect("operation should succeed");
             decrypted.extend_from_slice(&bytes);
         }
 
@@ -857,7 +857,7 @@ mod tests {
             let reader = BufReader::new(Cursor::new(data.to_vec()));
             let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
             let mut encrypted = Vec::new();
-            encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+            encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
             encrypted
         }
 
@@ -871,7 +871,7 @@ mod tests {
         let reader = BufReader::new(Cursor::new(combined));
         let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]);
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         let mut expected = Vec::with_capacity(part_one.len() + part_two.len());
         expected.extend_from_slice(&part_one);
@@ -891,7 +891,7 @@ mod tests {
         let reader = Cursor::new(data);
         let mut encrypt_reader = EncryptReader::new(reader, key, nonce);
         let mut encrypted = Vec::new();
-        encrypt_reader.read_to_end(&mut encrypted).await.unwrap();
+        encrypt_reader.read_to_end(&mut encrypted).await.expect("operation should succeed");
 
         let payloads = extract_encrypted_payloads(&encrypted);
         assert!(payloads.len() >= 2);
@@ -920,7 +920,7 @@ mod tests {
         let reader = Cursor::new(encrypted);
         let mut decrypt_reader = DecryptReader::new(reader, key, nonce);
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         assert_eq!(decrypted, data);
     }
@@ -945,7 +945,7 @@ mod tests {
         let reader = BufReader::new(Cursor::new(combined));
         let mut decrypt_reader = DecryptReader::new_multipart(reader, key, base_nonce, vec![1, 2]);
         let mut decrypted = Vec::new();
-        decrypt_reader.read_to_end(&mut decrypted).await.unwrap();
+        decrypt_reader.read_to_end(&mut decrypted).await.expect("operation should succeed");
 
         let mut expected = Vec::with_capacity(part_one.len() + part_two.len());
         expected.extend_from_slice(&part_one);
diff --git a/crates/targets/src/net.rs b/crates/targets/src/net.rs
index b9462e972..f10cb5d34 100644
--- a/crates/targets/src/net.rs
+++ b/crates/targets/src/net.rs
@@ -23,7 +23,7 @@ use std::sync::LazyLock;
 use thiserror::Error;
 use url::Url;
 
-static HOST_LABEL_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$").unwrap());
+static HOST_LABEL_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$").expect("operation should succeed"));
 
 /// NetError represents errors that can occur in network operations.
 #[derive(Error, Debug)]
@@ -332,7 +332,7 @@ impl<'de> serde::Deserialize<'de> for ParsedURL {
     {
         let s: String = serde::Deserialize::deserialize(deserializer)?;
         if s.is_empty() {
-            Ok(ParsedURL(Url::parse("about:blank").unwrap()))
+            Ok(ParsedURL(Url::parse("about:blank").expect("operation should succeed")))
         } else {
             parse_url(&s).map_err(serde::de::Error::custom)
         }
@@ -363,7 +363,7 @@ pub fn parse_url(s: &str) -> Result<ParsedURL, NetError> {
         });
 
         if !port_str.is_empty() {
-            let host_port = format!("{}:{}", uu.host_str().unwrap(), port_str);
+            let host_port = format!("{}:{}", uu.host_str().expect("operation should succeed"), port_str);
             parse_host(&host_port)?;
         }
     }
@@ -485,7 +485,7 @@ mod tests {
     fn parse_host_with_valid_ipv4() {
         let result = parse_host("192.168.1.1:8080");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "192.168.1.1");
         assert_eq!(host.port, Some(8080));
     }
@@ -494,7 +494,7 @@ mod tests {
     fn parse_host_with_valid_hostname() {
         let result = parse_host("example.com:443");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "example.com");
         assert_eq!(host.port, Some(443));
     }
@@ -503,7 +503,7 @@ mod tests {
     fn parse_host_with_ipv6_brackets() {
         let result = parse_host("[::1]:8080");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "::1");
         assert_eq!(host.port, Some(8080));
     }
@@ -512,7 +512,7 @@ mod tests {
     fn parse_host_with_bare_ipv6_without_port() {
         let result = parse_host("::1");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "::1");
         assert_eq!(host.port, None);
     }
@@ -521,7 +521,7 @@ mod tests {
     fn parse_host_with_ipv6_zone_without_port() {
         let result = parse_host("fe80::1%eth0");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "fe80::1%eth0");
         assert_eq!(host.port, None);
     }
@@ -530,7 +530,7 @@ mod tests {
     fn parse_host_with_bracketed_ipv6_zone_and_port() {
         let result = parse_host("[fe80::1%eth0]:9000");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "fe80::1%eth0");
         assert_eq!(host.port, Some(9000));
     }
@@ -539,7 +539,7 @@ mod tests {
     fn parse_host_with_bracketed_ipv6_without_port() {
         let result = parse_host("[::1]");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "::1");
         assert_eq!(host.port, None);
     }
@@ -560,7 +560,7 @@ mod tests {
     fn parse_host_without_port() {
         let result = parse_host("example.com");
         assert!(result.is_ok());
-        let host = result.unwrap();
+        let host = result.expect("operation should succeed");
         assert_eq!(host.name, "example.com");
         assert_eq!(host.port, None);
     }
@@ -605,7 +605,7 @@ mod tests {
     fn parse_url_with_valid_http_url() {
         let result = parse_url("http://example.com/path");
         assert!(result.is_ok());
-        let parsed = result.unwrap();
+        let parsed = result.expect("operation should succeed");
         assert_eq!(parsed.hostname(), "example.com");
         assert_eq!(parsed.port(), "80");
         assert_eq!(parsed.scheme(), "http");
@@ -616,7 +616,7 @@ mod tests {
     fn parse_url_with_explicit_default_https_port() {
         let result = parse_url("https://example.com:443/path");
         assert!(result.is_ok());
-        let parsed = result.unwrap();
+        let parsed = result.expect("operation should succeed");
         assert_eq!(parsed.to_string(), "https://example.com/path");
     }
 
@@ -636,7 +636,7 @@ mod tests {
     fn parse_url_normalizes_path() {
         let result = parse_url("http://example.com//path/../path/");
         assert!(result.is_ok());
-        let parsed = result.unwrap();
+        let parsed = result.expect("operation should succeed");
         assert_eq!(parsed.to_string(), "http://example.com/path/");
     }
 }
diff --git a/rustfs/src/admin/handlers/kms_management.rs b/rustfs/src/admin/handlers/kms_management.rs
index ceb6e0cb8..0ff25a7dc 100644
--- a/rustfs/src/admin/handlers/kms_management.rs
+++ b/rustfs/src/admin/handlers/kms_management.rs
@@ -208,7 +208,7 @@ impl Operation for KmsStatusHandler {
         let data = serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
 
         let mut headers = HeaderMap::new();
-        headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
+        headers.insert(CONTENT_TYPE, "application/json".parse().expect("operation should succeed"));
 
         Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
     }
@@ -257,7 +257,7 @@ impl Operation for KmsConfigHandler {
         let data = serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
 
         let mut headers = HeaderMap::new();
-        headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
+        headers.insert(CONTENT_TYPE, "application/json".parse().expect("operation should succeed"));
 
         Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
     }
@@ -302,7 +302,7 @@ impl Operation for KmsClearCacheHandler {
                     serde_json::to_vec(&response).map_err(|e| s3_error!(InternalError, "failed to serialize response: {}", e))?;
 
                 let mut headers = HeaderMap::new();
-                headers.insert(CONTENT_TYPE, "application/json".parse().unwrap());
+                headers.insert(CONTENT_TYPE, "application/json".parse().expect("operation should succeed"));
 
                 Ok(S3Response::with_headers((StatusCode::OK, Body::from(data)), headers))
             }