Remove excess logging

Author: johnramsden

oxcache/src/device.rs

@@ -216,10 +216,6 @@ fn check_first_evict_bench() {
 }
 
 fn trigger_eviction(eviction_channel: Sender<EvictorMessage>) -> io::Result<()> {
-    tracing::info!(
-        "[trigger_eviction] Thread {:?} triggering eviction and BLOCKING for response",
-        std::thread::current().id()
-    );
     let (resp_tx, resp_rx) = flume::bounded(1);
     if let Err(e) = eviction_channel.send(EvictorMessage { sender: resp_tx }) {
         tracing::error!("[append] Failed to send eviction message: {}", e);
@@ -229,18 +225,9 @@ fn trigger_eviction(eviction_channel: Sender<EvictorMessage>) -> io::Result<()>
         ));
     };
 
-    tracing::info!(
-        "[trigger_eviction] Thread {:?} WAITING for eviction response...",
-        std::thread::current().id()
-    );
     match resp_rx.recv() {
         Ok(result) => match result {
-            Ok(_) => {
-                tracing::info!(
-                    "[trigger_eviction] Thread {:?} eviction completed successfully, UNBLOCKING",
-                    std::thread::current().id()
-                );
-            }
+            Ok(_) => { }
             Err(e) => {
                 tracing::error!(
                     "[trigger_eviction] Thread {:?} eviction FAILED: {}",
@@ -292,21 +279,13 @@ impl Zoned {
             },
             Err(error) => match error {
                 ZoneObtainFailure::EvictNow => {
-                    tracing::warn!("[get_free_zone] Thread {:?} got EvictNow (is_eviction={})",
-                        std::thread::current().id(), is_eviction);
                     Err(io::Error::new(ErrorKind::StorageFull, "Cache is full"))
                 }
                 ZoneObtainFailure::Wait => {
-                    tracing::info!("[get_free_zone] Thread {:?} entering condvar wait (is_eviction={}, free={}, open={})",
-                        std::thread::current().id(), is_eviction, zone_list.free_zones.len(), zone_list.open_zones.len());
                     loop {
                         zone_list = wait_notify.wait(zone_list).unwrap();
-                        tracing::info!("[get_free_zone] Thread {:?} woke up from condvar (is_eviction={}, free={}, open={})",
-                            std::thread::current().id(), is_eviction, zone_list.free_zones.len(), zone_list.open_zones.len());
                         match zone_list.remove_with_eviction_bypass(is_eviction) {
                             Ok(idx) => {
-                                tracing::info!("[get_free_zone] Thread {:?} got zone {} after wait",
-                                    std::thread::current().id(), idx);
                                 return Ok(idx);
                             },
                             Err(err) => match err {
@@ -316,8 +295,6 @@ impl Zoned {
                                     return Err(io::Error::new(ErrorKind::Other, "Cache is full"));
                                 }
                                 ZoneObtainFailure::Wait => {
-                                    tracing::info!("[get_free_zone] Thread {:?} needs to wait again",
-                                        std::thread::current().id());
                                     continue;
                                 },
                             },
@@ -342,12 +319,7 @@ impl Zoned {
         // come and try to open a new zone if needed.
         // Skip notification during eviction batch writes to avoid race condition
         if !suppress_notify {
-            tracing::info!("[complete_write] Zone {} finished, notifying ALL waiters (free={}, open={})",
-                zone_idx, zone_list.free_zones.len(), zone_list.open_zones.len());
             notify.notify_all();
-        } else {
-            tracing::info!("[complete_write] Zone {} finished during eviction, SUPPRESSING notify (free={}, open={})",
-                zone_idx, zone_list.free_zones.len(), zone_list.open_zones.len());
         }
 
         Ok(())
@@ -735,7 +707,6 @@ impl Device for Zoned {
                         // Remove from open_zones so no new chunks can be allocated from this zone
                         zones.open_zones.retain(|z| z != zone);
                     }
-                    tracing::info!("[Evict:Chunk] Locked {} zones for cleaning", clean_locations.len());
                 }
 
                 // Cleaning
@@ -791,12 +762,6 @@ impl Device for Zoned {
                             // Writer callback
                             |payloads: Vec<(CacheKey, bytes::Bytes)>| {
                                 async move {
-                                    tracing::info!(
-                                        "[evict:Chunk] Starting zone {} cleaning, {} valid chunks to relocate",
-                                        zone,
-                                        payloads.len()
-                                    );
-
                                     // Remove old LRU entries FIRST, before reset_zone makes the zone available again
                                     // This prevents relocated chunks from being accidentaly added then removed
                                     {
@@ -813,11 +778,7 @@ impl Device for Zoned {
                                             .unwrap();
                                         let (zone_mtx, cv) = &*self_clone.zones;
                                         let mut zones = zone_mtx.lock().unwrap();
-                                        tracing::info!("[evict:Chunk] Resetting zone {} (free={}, open={} before reset)",
-                                            zone, zones.free_zones.len(), zones.open_zones.len());
                                         zones.reset_zone(*zone, &*self_clone)?;
-                                        tracing::info!("[evict:Chunk] Zone {} reset complete (free={}, open={} after reset)",
-                                            zone, zones.free_zones.len(), zones.open_zones.len());
                                         cv
                                     }; // Drop the mutex, so we don't have to put it in an await
 
@@ -827,17 +788,13 @@ impl Device for Zoned {
                                     let data_vec: Vec<_> =
                                         payloads.iter().map(|(_, data)| data.clone()).collect();
 
-                                    // Used to verify no RACE, TODO: Remove!
-                                    // tokio::time::sleep(Duration::from_secs(5)).await;
-
                                     let (batch_tx, batch_rx) = flume::bounded(1);
 
                                     let batch_request = BatchWriteRequest {
                                         data: data_vec,
                                         responder: batch_tx,
                                     };
 
-                                    tracing::info!("[evict:Chunk] Sending batch write for zone {} with {} chunks", zone, batch_request.data.len());
                                     writer_pool.send_priority_batch(batch_request).await?;
 
                                     let batch_response =
@@ -866,12 +823,6 @@ impl Device for Zoned {
 
                                     let write_results = write_results?;
 
-                                    tracing::info!(
-                                        "[evict:Chunk] Batch write completed for zone {}, {} chunks written, notifying ALL waiters",
-                                        zone,
-                                        write_results.len()
-                                    );
-
                                     // Notify waiting writers AFTER batch write completes successfully
                                     cv.notify_all();
 

oxcache/src/eviction.rs

@@ -298,7 +298,6 @@ impl EvictionPolicy for ChunkEvictionPolicy {
         );
 
         if !always_evict && lru_len < high_water_mark {
-            tracing::info!("[ChunkPolicy] Below high water mark, no eviction needed");
             return vec![];
         }
 
@@ -310,7 +309,6 @@ impl EvictionPolicy for ChunkEvictionPolicy {
         }
 
         let count_to_evict = lru_len - low_water_mark;
-        tracing::info!("[ChunkPolicy] Will evict {} chunks", count_to_evict);
 
         let mut targets = Vec::with_capacity(count_to_evict as usize);
         let mut zone_counts = std::collections::HashMap::new();
@@ -331,12 +329,6 @@ impl EvictionPolicy for ChunkEvictionPolicy {
             self.pq.modify_priority(zone, count);
         }
 
-        tracing::info!(
-            "[ChunkPolicy] Evicted {} chunks, LRU now has {} entries",
-            targets.len(),
-            self.lru.len()
-        );
-
         #[cfg(feature = "eviction-metrics")]
         if let Some(ref metrics) = self.metrics {
             metrics.record_chunk_evictions(&targets);
@@ -346,37 +338,24 @@ impl EvictionPolicy for ChunkEvictionPolicy {
     }
 
     fn get_clean_targets(&mut self, _force_clean: bool) -> Self::CleanTarget {
-        // Always use threshold-based cleaning (simpler, no force mode needed)
-        let clean_targets = self.pq.remove_if_thresh_met(false);
+        let clean_targets = self.pq.remove_if_thresh_met();
 
         if clean_targets.is_empty() {
-            tracing::info!("[ChunkPolicy] No zones meet cleaning threshold");
             return clean_targets;
         }
 
-        tracing::info!(
-            "[ChunkPolicy] Will clean {} zones based on priority queue",
-            clean_targets.len()
-        );
-
         clean_targets
     }
 }
 
 impl ChunkEvictionPolicy {
     /// Remove old LRU entries after chunks are relocated during zone cleaning.
-    /// Note: New entries are automatically added by writer pool calling write_update()
     pub fn chunks_relocated(&mut self, old_locations: &[ChunkLocation]) {
         for old_loc in old_locations {
             // Remove stale entry from LRU
             // The relocated chunk's new location is already in LRU via write_update()
             self.lru.remove(old_loc);
         }
-
-        tracing::debug!(
-            "[ChunkPolicy] Removed {} old LRU entries after relocation",
-            old_locations.len()
-        );
     }
 }
 
@@ -427,9 +406,7 @@ impl Evictor {
                     }
                 };
 
-                tracing::info!("[Evictor] Starting eviction (always_evict={})", always_evict);
                 let device_clone = device_clone.clone();
-                let eviction_start = std::time::Instant::now();
                 let result = match device_clone.evict(
                     cache_clone.clone(),
                     writer_pool.clone(),
@@ -445,8 +422,6 @@ impl Evictor {
                         Ok(())
                     },
                 };
-                let eviction_duration = eviction_start.elapsed();
-                tracing::info!("[Evictor] Total eviction took {:?}", eviction_duration);
 
                 if let Some(sender) = sender {
                     tracing::debug!("Sending eviction response to sender: {:?}", result);

oxcache/src/writerpool.rs

@@ -116,7 +116,6 @@ impl Writer {
     }
     fn receive_priority(&self) {
         while let Ok(batch_msg) = self.priority_receiver.recv() {
-            tracing::info!("[WriterPool] Priority-only writer {} received batch request", self.id);
             self.process_batch_request(batch_msg);
         }
     }
@@ -184,20 +183,12 @@ impl Writer {
 
     fn process_batch_request(&self, batch_req: BatchWriteRequest) {
         let data_len = batch_req.data.len(); // Store length before moving
-        tracing::info!("[WriterPool] Priority writer {} starting batch of {} chunks", self.id, data_len);
         let mut locations = Vec::with_capacity(data_len);
 
         for (i, data) in batch_req.data.into_iter().enumerate() {
-            tracing::info!("[WriterPool] Priority writer {} processing chunk {}/{}", self.id, i+1, data_len);
             // Use eviction bypass for priority batch requests (eviction writes)
             let result = self.device.append_with_eviction_bypass(data, true);
 
-            if let Err(ref e) = result {
-                tracing::error!("[WriterPool] Priority writer {} chunk {}/{} FAILED: {}", self.id, i+1, data_len, e);
-            } else {
-                tracing::info!("[WriterPool] Priority writer {} chunk {}/{} succeeded", self.id, i+1, data_len);
-            }
-
             if let Ok(ref loc) = result {
                 let mtx = Arc::clone(&self.eviction);
                 let policy = mtx.lock().unwrap();
@@ -235,12 +226,9 @@ impl Writer {
         }
 
         let resp = BatchWriteResponse { locations };
-        tracing::info!("[WriterPool] Priority writer {} completed batch, sending response", self.id);
         let snd = batch_req.responder.send(resp);
         if snd.is_err() {
             tracing::error!("Failed to send batch response from writer");
-        } else {
-            tracing::info!("[WriterPool] Priority writer {} batch response sent successfully", self.id);
         }
     }
 }

oxcache/src/zone_state/zone_priority_queue.rs

@@ -37,57 +37,14 @@ impl ZonePriorityQueue {
 
     // If above high watermark, clean until strictly below low watermark
     // If force_all=true, clean ALL zones with invalid chunks (desperate/always_evict mode)
-    pub fn remove_if_thresh_met(&mut self, force_all: bool) -> Vec<ZoneIndex> {
+    pub fn remove_if_thresh_met(&mut self) -> Vec<ZoneIndex> {
         let mut zones = Vec::new();
 
-        // Count how many zones have invalid chunks
-        let zones_with_invalids = self.invalid_queue.iter().filter(|(_, p)| **p > 0).count();
-
-        tracing::info!(
-            "[PriorityQueue] remove_if_thresh_met called: invalid_count={}, low_water_thresh={}, force_all={}, zones_with_invalids={}, will_clean={}",
-            self.invalid_count,
-            self.low_water_thresh,
-            force_all,
-            zones_with_invalids,
-            force_all || self.invalid_count >= self.low_water_thresh
-        );
-
-        if force_all && zones_with_invalids > 0 {
-            // Desperate mode: clean ALL zones with invalid chunks
-            tracing::warn!(
-                "[PriorityQueue] ⚠️  FORCE CLEANING all {} zones with invalid chunks (always_evict=true)!",
-                zones_with_invalids
-            );
-            while let Some((zone, prio)) = self.invalid_queue.peek() {
-                if *prio == 0 {
-                    break; // No more zones with invalid chunks
-                }
-                tracing::info!(
-                    "[PriorityQueue] Force cleaning zone {} with {} invalid chunks",
-                    zone, prio
-                );
-                zones.push(self.pop_reset());
-            }
-        } else {
-            // Normal mode: clean until below threshold
-            while self.invalid_count >= self.low_water_thresh {
-                let (zone, prio) = self.invalid_queue.peek().unwrap();
-                tracing::info!(
-                    "[PriorityQueue] Cleaning zone {} with {} invalid chunks (invalid_count={} >= thresh={})",
-                    zone, prio, self.invalid_count, self.low_water_thresh
-                );
-                zones.push(self.pop_reset());
-            }
+        // Clean until below threshold
+        while self.invalid_count >= self.low_water_thresh {
+            zones.push(self.pop_reset());
         }
 
-        let zones_with_invalids_after = self.invalid_queue.iter().filter(|(_, p)| **p > 0).count();
-        tracing::info!(
-            "[PriorityQueue] After cleaning: returning {} zones, invalid_count={}, {} zones still have invalid chunks",
-            zones.len(),
-            self.invalid_count,
-            zones_with_invalids_after
-        );
-
         zones
     }