fix: address correctness, safety, and concurrency issues (#2327)

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: houseme <housemecn@gmail.com>

crates/io-metrics/examples/metrics_example.rs

@@ -0,0 +1,149 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Example demonstrating metrics and configuration usage.
+
+use rustfs_io_metrics::{
+    AccessTracker, AdaptiveTTL, CacheConfig, CacheSettings, IoConfig, IoSchedulerSettings, record_cache_size,
+};
+use std::time::Duration;
+
+fn main() {
+    println!("=== rustfs-io-metrics Example ===\n");
+
+    // 1. Cache configuration example
+    cache_config_example();
+
+    // 2. Adaptive TTL example
+    adaptive_ttl_example();
+
+    // 3. Access tracking example
+    access_tracker_example();
+
+    // 4. Unified configuration example
+    unified_config_example();
+
+    // 5. Metrics recording example
+    metrics_recording_example();
+}
+
+fn cache_config_example() {
+    println!("--- Cache Configuration ---");
+
+    // Create default configuration
+    let config = CacheConfig::new();
+    println!("  Max capacity: {}", config.max_capacity);
+    println!("  Default TTL: {} seconds", config.default_ttl().as_secs());
+    println!("  Max memory: {} bytes", config.max_memory_bytes);
+
+    // Validate configuration
+    match config.validate() {
+        Ok(()) => println!("  Validation: passed"),
+        Err(e) => println!("  Validation: failed - {}", e),
+    }
+
+    // Custom configuration
+    let custom_config = CacheConfig::new().with_max_capacity(5000).with_ttl_range(60, 600, 3600);
+    println!("  Custom capacity: {}", custom_config.max_capacity);
+
+    println!();
+}
+
+fn adaptive_ttl_example() {
+    println!("--- Adaptive TTL ---");
+
+    let config = CacheConfig::new().with_ttl_range(60, 300, 3600);
+    let ttl = AdaptiveTTL::new(config);
+
+    // Calculate TTL for different access frequencies
+    let access_counts = [0u64, 1, 3, 5, 10, 20];
+    for count in access_counts {
+        let calculated = ttl.calculate_ttl(Duration::from_secs(60), count, 0.8);
+        println!("  Access {} times: TTL = {} seconds", count, calculated.as_secs());
+    }
+
+    // Check if should evict early
+    let should_evict = ttl.should_evict_early(1, Duration::from_secs(30), Duration::from_secs(300));
+    println!("  Should evict low-frequency item early: {}", should_evict);
+
+    println!();
+}
+
+fn access_tracker_example() {
+    println!("--- Access Tracking ---");
+
+    let mut tracker = AccessTracker::new(100, Duration::from_secs(300));
+
+    // Simulate accesses
+    let objects = [("hot-object", 10), ("warm-object", 5), ("cold-object", 1)];
+
+    for (key, count) in objects {
+        for _ in 0..count {
+            tracker.record_access(key, 1024);
+        }
+    }
+
+    // Query access information
+    for (key, _) in objects {
+        let count = tracker.get_access_count(key);
+        let is_hot = tracker.is_hot(key, 5);
+        let is_cold = tracker.is_cold(key, 5);
+        println!("  {}: count={}, hot={}, cold={}", key, count, is_hot, is_cold);
+    }
+
+    // Get top keys
+    let top_keys = tracker.top_keys(3);
+    println!("  Top keys: {:?}", top_keys);
+
+    println!();
+}
+
+fn unified_config_example() {
+    println!("--- Unified Configuration ---");
+
+    let config = IoConfig::new()
+        .with_cache(
+            CacheSettings::new()
+                .with_max_capacity(5000)
+                .with_ttl(Duration::from_secs(600)),
+        )
+        .with_scheduler(IoSchedulerSettings::new().with_max_concurrent_reads(64));
+
+    println!("  Cache capacity: {}", config.cache.max_capacity);
+    println!("  Cache TTL: {:?}", config.cache.default_ttl);
+    println!("  Max concurrent reads: {}", config.scheduler.max_concurrent_reads);
+    println!("  Backpressure high watermark: {}", config.backpressure.high_watermark);
+    println!("  Default timeout: {:?}", config.timeout.default_timeout);
+
+    println!();
+}
+
+fn metrics_recording_example() {
+    println!("--- Metrics Recording ---");
+
+    // Record cache operations
+    for i in 0..10 {
+        if i % 3 == 0 {
+            record_cache_size("L1", 0, 0); // miss
+        } else {
+            record_cache_size("L1", 1024, 1); // hit
+        }
+    }
+
+    println!("  Recorded 10 cache operations (hits: 7, misses: 3)");
+    println!("  Metrics reported via metrics crate");
+    println!("  View via Prometheus/Grafana");
+
+    println!();
+}