Enable Foyer cache in CI with small disk sizes

Instead of disabling Foyer entirely, use small cache sizes (50MB disk)
similar to the test_config. This ensures integration tests exercise the
cache while avoiding the slow disk pre-allocation.

Added _DISK_MB env vars for fine-grained control over cache sizes.

Author: tonyalaribe

.github/workflows/ci.yml

@@ -63,7 +63,12 @@ jobs:
       MAX_PG_CONNECTIONS: "100"
       AWS_S3_LOCKING_PROVIDER: ""
       WALRUS_DATA_DIR: /tmp/walrus-wal
-      TIMEFUSION_FOYER_DISABLED: "true"
+      # Use small cache sizes for CI tests (similar to test_config in object_store_cache.rs)
+      TIMEFUSION_FOYER_MEMORY_MB: "10"
+      TIMEFUSION_FOYER_DISK_MB: "50"
+      TIMEFUSION_FOYER_METADATA_MEMORY_MB: "10"
+      TIMEFUSION_FOYER_METADATA_DISK_MB: "50"
+      TIMEFUSION_FOYER_SHARDS: "2"
     services:
       minio:
         image: public.ecr.aws/bitnami/minio:latest

src/database.rs

@@ -297,12 +297,6 @@ impl Database {
     }
 
     async fn initialize_cache_with_retry() -> Option<Arc<SharedFoyerCache>> {
-        // Allow disabling cache for testing
-        if env::var("TIMEFUSION_FOYER_DISABLED").is_ok() {
-            info!("Foyer cache disabled via TIMEFUSION_FOYER_DISABLED environment variable");
-            return None;
-        }
-
         let config = FoyerCacheConfig::from_env();
         info!(
             "Initializing shared Foyer hybrid cache (memory: {}MB, disk: {}GB, TTL: {}s)",

src/object_store_cache.rs

@@ -135,17 +135,32 @@ impl FoyerCacheConfig {
             std::env::var(key).ok().and_then(|v| v.parse().ok()).unwrap_or(default)
         }
 
+        // Support both MB and GB for disk sizes (MB takes precedence for smaller test configs)
+        let disk_size_bytes =
+            if let Ok(mb) = std::env::var("TIMEFUSION_FOYER_DISK_MB").and_then(|v| v.parse::<usize>().map_err(|_| std::env::VarError::NotPresent)) {
+                mb * 1024 * 1024
+            } else {
+                parse_env::<usize>("TIMEFUSION_FOYER_DISK_GB", 100) * 1024 * 1024 * 1024
+            };
+
+        let metadata_disk_size_bytes =
+            if let Ok(mb) = std::env::var("TIMEFUSION_FOYER_METADATA_DISK_MB").and_then(|v| v.parse::<usize>().map_err(|_| std::env::VarError::NotPresent)) {
+                mb * 1024 * 1024
+            } else {
+                parse_env::<usize>("TIMEFUSION_FOYER_METADATA_DISK_GB", 5) * 1024 * 1024 * 1024
+            };
+
         Self {
             memory_size_bytes: parse_env::<usize>("TIMEFUSION_FOYER_MEMORY_MB", 512) * 1024 * 1024,
-            disk_size_bytes: parse_env::<usize>("TIMEFUSION_FOYER_DISK_GB", 100) * 1024 * 1024 * 1024,
+            disk_size_bytes,
             ttl: Duration::from_secs(parse_env("TIMEFUSION_FOYER_TTL_SECONDS", 604800)),
             cache_dir: PathBuf::from(parse_env("TIMEFUSION_FOYER_CACHE_DIR", "/tmp/timefusion_cache".to_string())),
             shards: parse_env("TIMEFUSION_FOYER_SHARDS", 8),
             file_size_bytes: parse_env::<usize>("TIMEFUSION_FOYER_FILE_SIZE_MB", 32) * 1024 * 1024,
             enable_stats: parse_env("TIMEFUSION_FOYER_STATS", "true".to_string()).to_lowercase() == "true",
             parquet_metadata_size_hint: parse_env("TIMEFUSION_PARQUET_METADATA_SIZE_HINT", 1_048_576),
             metadata_memory_size_bytes: parse_env::<usize>("TIMEFUSION_FOYER_METADATA_MEMORY_MB", 512) * 1024 * 1024,
-            metadata_disk_size_bytes: parse_env::<usize>("TIMEFUSION_FOYER_METADATA_DISK_GB", 5) * 1024 * 1024 * 1024,
+            metadata_disk_size_bytes,
             metadata_shards: parse_env("TIMEFUSION_FOYER_METADATA_SHARDS", 4),
         }
     }