refactor: remove duplicate debug logs and bench recon instrumentation

Author: XciD

src/cached_xet_client.rs

@@ -11,7 +11,6 @@ use cas_types::{
 };
 use mdb_shard::file_structs::MDBFileInfo;
 use merklehash::MerkleHash;
-use tracing::debug;
 
 type Result<T> = std::result::Result<T, cas_client::CasClientError>;
 
@@ -150,7 +149,6 @@ impl Client for CachedXetClient {
 
         if let Some(full) = cached_full {
             if let Some(range) = bytes_range {
-                debug!("reconstruction derived from full-file cache for {file_id}");
                 let resp = derive_range_response(&full, range);
                 // Mirror the CAS server's EOF contract:
                 // - Non-empty file, range past EOF → None
@@ -167,7 +165,6 @@ impl Client for CachedXetClient {
                 );
                 return Ok(Some(resp));
             } else {
-                debug!("reconstruction cache hit for {file_id}");
                 tracing::debug!("recon: HIT  file={:.8} range=None terms={}", file_id, full.terms.len());
                 return Ok(Some(full));
             }

tests/bench.rs

@@ -1,73 +1,5 @@
 mod common;
 
-struct ReconStats {
-    cas: usize,
-    hit: usize,
-    derv: usize,
-}
-
-/// Spawn hf-mount-fuse with RUST_LOG=hf_mount::cached_xet_client=debug and stderr
-/// redirected to `log_path`. Used by the bench to count CAS/HIT/DERV calls.
-fn mount_bucket_bench(
-    bucket_id: &str,
-    mount_point: &str,
-    cache_dir: &str,
-    log_path: &std::path::Path,
-) -> std::process::Child {
-    let token = std::env::var("HF_TOKEN").unwrap();
-    let binary = std::env::current_exe()
-        .unwrap()
-        .parent()
-        .unwrap()
-        .parent()
-        .unwrap()
-        .join("hf-mount-fuse");
-    let ep = common::endpoint();
-    std::fs::create_dir_all(mount_point).ok();
-    std::fs::create_dir_all(cache_dir).ok();
-    // tracing_subscriber::fmt() writes to stdout by default; clone fd to also capture stderr.
-    let log_file = std::fs::File::create(log_path).expect("create bench log file");
-    let log_file2 = log_file.try_clone().expect("clone bench log file");
-    let child = std::process::Command::new(&binary)
-        .args([
-            "--hf-token",
-            &token,
-            "--hub-endpoint",
-            &ep,
-            "--cache-dir",
-            cache_dir,
-            "--poll-interval-secs",
-            "0",
-        ])
-        .args(["bucket", bucket_id, mount_point])
-        .env("RUST_LOG", "hf_mount::cached_xet_client=debug")
-        .stdout(log_file)
-        .stderr(log_file2)
-        .spawn()
-        .expect("Failed to spawn hf-mount-fuse");
-    for i in 0..30 {
-        std::thread::sleep(std::time::Duration::from_millis(500));
-        if let Ok(mounts) = std::fs::read_to_string("/proc/mounts")
-            && mounts.lines().any(|line| line.contains(mount_point))
-        {
-            eprintln!("Mount ready after {}ms", (i + 1) * 500);
-            return child;
-        }
-    }
-    eprintln!("Warning: mount may not be ready after 15s");
-    child
-}
-
-/// Parse a recon log file and count CAS/HIT/DERV lines.
-fn parse_recon_stats(log_path: &std::path::Path) -> ReconStats {
-    let content = std::fs::read_to_string(log_path).unwrap_or_default();
-    ReconStats {
-        cas: content.lines().filter(|l| l.contains("recon: CAS")).count(),
-        hit: content.lines().filter(|l| l.contains("recon: HIT")).count(),
-        derv: content.lines().filter(|l| l.contains("recon: DERV")).count(),
-    }
-}
-
 const BENCH_SIZES: &[(usize, &str)] = &[
     (50 * 1024 * 1024, "50MB"),
     (200 * 1024 * 1024, "200MB"),
@@ -120,10 +52,9 @@ async fn test_bench() {
     // --- FUSE benchmark (read + write per size) ---
     let fuse_mount = format!("/tmp/hf-bench-fuse-{}", pid);
     let fuse_cache = format!("/tmp/hf-bench-fuse-cache-{}", pid);
-    let fuse_log = std::path::PathBuf::from(format!("/tmp/hf-bench-fuse-recon-{}.log", pid));
 
     let fuse_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        let child = mount_bucket_bench(&bucket_id, &fuse_mount, &fuse_cache, &fuse_log);
+        let child = common::mount_bucket(&bucket_id, &fuse_mount, &fuse_cache, &[]);
 
         let mut reads = Vec::new();
         for (filename, expected) in &files {
@@ -139,8 +70,6 @@ async fn test_bench() {
         (reads, writes)
     }));
 
-    let fuse_recon = parse_recon_stats(&fuse_log);
-    std::fs::remove_file(&fuse_log).ok();
     std::fs::remove_dir_all(&fuse_mount).ok();
     std::fs::remove_dir_all(&fuse_cache).ok();
 
@@ -227,21 +156,6 @@ async fn test_bench() {
     }
     eprintln!();
 
-    // --- FUSE reconstruction call stats (total across all reads) ---
-    eprintln!("============================================================");
-    eprintln!("  FUSE Reconstruction Calls (total read session)");
-    eprintln!("------------------------------------------------------------");
-    eprintln!("  {:30} {:>12}", "CAS calls (network)", fuse_recon.cas);
-    eprintln!("  {:30} {:>12}", "HIT calls (in-memory cache)", fuse_recon.hit);
-    eprintln!("  {:30} {:>12}", "DERV calls (derived from cache)", fuse_recon.derv);
-    eprintln!(
-        "  {:30} {:>12}",
-        "Total",
-        fuse_recon.cas + fuse_recon.hit + fuse_recon.derv
-    );
-    eprintln!("============================================================");
-    eprintln!();
-
     // Assertions
     for (i, &(_, label)) in BENCH_SIZES.iter().enumerate() {
         assert!(fuse_reads[i].is_ok(), "FUSE read benchmark failed for {}", label);