foxhunt/benches/comprehensive/metrics_overhead.rs

//! Metrics Collection Overhead Benchmarks
//!
//! Validates metrics performance targets:
//! - Observation overhead: <5μs per metric
//! - Registry size impact: O(1) lookup
//! - Cardinality performance: >1000 unique labels
//! - Aggregation overhead: <100μs per aggregation
//!
//! Critical for ensuring observability doesn't impact trading latency.

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::Duration;

/// Mock metric types
#[derive(Clone, Debug)]
enum MetricType {
    Counter,
    Gauge,
    Histogram,
}

/// Mock metric observation
#[derive(Clone, Debug)]
struct MetricObservation {
    name: String,
    labels: HashMap<String, String>,
    value: f64,
    timestamp: u64,
}

/// Mock metrics registry
struct MetricsRegistry {
    counters: Arc<Mutex<HashMap<String, f64>>>,
    gauges: Arc<Mutex<HashMap<String, f64>>>,
    histograms: Arc<Mutex<HashMap<String, Vec<f64>>>>,
}

impl MetricsRegistry {
    fn new() -> Self {
        Self {
            counters: Arc::new(Mutex::new(HashMap::new())),
            gauges: Arc::new(Mutex::new(HashMap::new())),
            histograms: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    
    fn observe_counter(&self, name: String, value: f64) {
        let mut counters = self.counters.lock().unwrap();
        *counters.entry(name).or_insert(0.0) += value;
    }
    
    fn observe_gauge(&self, name: String, value: f64) {
        let mut gauges = self.gauges.lock().unwrap();
        gauges.insert(name, value);
    }
    
    fn observe_histogram(&self, name: String, value: f64) {
        let mut histograms = self.histograms.lock().unwrap();
        histograms.entry(name).or_insert_with(Vec::new).push(value);
    }
    
    fn metric_count(&self) -> usize {
        self.counters.lock().unwrap().len()
            + self.gauges.lock().unwrap().len()
            + self.histograms.lock().unwrap().len()
    }
}

/// Benchmark metric observation overhead
fn bench_observation_overhead(c: &mut Criterion) {
    let mut group = c.benchmark_group("observation_overhead");
    group.throughput(Throughput::Elements(1));
    
    let registry = MetricsRegistry::new();
    
    group.bench_function("counter_increment", |b| {
        b.iter(|| {
            registry.observe_counter("requests_total".to_string(), 1.0);
            black_box(&registry)
        });
    });
    
    group.bench_function("gauge_set", |b| {
        b.iter(|| {
            registry.observe_gauge("queue_size".to_string(), 42.0);
            black_box(&registry)
        });
    });
    
    group.bench_function("histogram_observe", |b| {
        b.iter(|| {
            registry.observe_histogram("request_duration_ms".to_string(), 15.5);
            black_box(&registry)
        });
    });
    
    group.finish();
}

/// Benchmark registry lookup performance
fn bench_registry_lookup(c: &mut Criterion) {
    let mut group = c.benchmark_group("registry_lookup");
    
    for num_metrics in &[10, 100, 1000, 10000] {
        group.bench_with_input(
            BenchmarkId::new("metrics", num_metrics),
            num_metrics,
            |b, &count| {
                let registry = MetricsRegistry::new();
                
                // Pre-populate registry
                for i in 0..count {
                    registry.observe_counter(format!("metric_{}", i), 1.0);
                }
                
                b.iter(|| {
                    // Lookup random metric
                    let metric_name = format!("metric_{}", count / 2);
                    registry.observe_counter(metric_name, 1.0);
                    black_box(&registry)
                });
            },
        );
    }
    
    group.finish();
}

/// Benchmark label cardinality impact
fn bench_label_cardinality(c: &mut Criterion) {
    let mut group = c.benchmark_group("label_cardinality");
    
    for num_labels in &[1, 5, 10, 20] {
        group.bench_with_input(
            BenchmarkId::new("labels", num_labels),
            num_labels,
            |b, &labels| {
                b.iter(|| {
                    let mut label_map = HashMap::new();
                    for i in 0..labels {
                        label_map.insert(format!("label_{}", i), format!("value_{}", i));
                    }
                    
                    let observation = MetricObservation {
                        name: "request_latency".to_string(),
                        labels: label_map,
                        value: 42.0,
                        timestamp: 0,
                    };
                    
                    black_box(observation)
                });
            },
        );
    }
    
    group.finish();
}

/// Benchmark metric aggregation
fn bench_aggregation(c: &mut Criterion) {
    let mut group = c.benchmark_group("metric_aggregation");
    
    for sample_count in &[100, 1000, 10000] {
        group.throughput(Throughput::Elements(*sample_count as u64));
        group.bench_with_input(
            BenchmarkId::new("samples", sample_count),
            sample_count,
            |b, &count| {
                b.iter_batched(
                    || {
                        // Generate sample data
                        (0..count).map(|i| i as f64).collect::<Vec<_>>()
                    },
                    |samples| {
                        // Calculate percentiles
                        let mut sorted = samples.clone();
                        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
                        
                        let p50 = sorted[count / 2];
                        let p95 = sorted[(count * 95) / 100];
                        let p99 = sorted[(count * 99) / 100];
                        
                        black_box((p50, p95, p99))
                    },
                    criterion::BatchSize::SmallInput,
                );
            },
        );
    }
    
    group.finish();
}

/// Benchmark concurrent metric updates
fn bench_concurrent_updates(c: &mut Criterion) {
    let mut group = c.benchmark_group("concurrent_updates");
    
    for num_threads in &[1, 2, 4, 8] {
        group.bench_with_input(
            BenchmarkId::new("threads", num_threads),
            num_threads,
            |b, &threads| {
                b.iter(|| {
                    let registry = Arc::new(MetricsRegistry::new());
                    let mut handles = vec![];
                    
                    for t in 0..threads {
                        let reg = Arc::clone(&registry);
                        let handle = std::thread::spawn(move || {
                            for i in 0..100 {
                                reg.observe_counter(format!("counter_{}_{}", t, i), 1.0);
                            }
                        });
                        handles.push(handle);
                    }
                    
                    for handle in handles {
                        handle.join().unwrap();
                    }
                    
                    black_box(registry)
                });
            },
        );
    }
    
    group.finish();
}

/// Benchmark histogram bucket operations
fn bench_histogram_buckets(c: &mut Criterion) {
    let mut group = c.benchmark_group("histogram_buckets");
    
    for num_buckets in &[10, 50, 100] {
        group.bench_with_input(
            BenchmarkId::new("buckets", num_buckets),
            num_buckets,
            |b, &buckets| {
                b.iter(|| {
                    // Simulate finding appropriate bucket
                    let value = 42.5;
                    let bucket_boundaries: Vec<f64> = (0..buckets)
                        .map(|i| (i as f64) * 10.0)
                        .collect();
                    
                    let bucket = bucket_boundaries
                        .iter()
                        .position(|&b| value < b)
                        .unwrap_or(buckets - 1);
                    
                    black_box(bucket)
                });
            },
        );
    }
    
    group.finish();
}

criterion_group! {
    name = metrics_benchmarks;
    config = Criterion::default()
        .measurement_time(Duration::from_secs(10))
        .sample_size(1000)
        .warm_up_time(Duration::from_secs(2))
        .with_plots();
    targets =
        bench_observation_overhead,
        bench_registry_lookup,
        bench_label_cardinality,
        bench_aggregation,
        bench_concurrent_updates,
        bench_histogram_buckets
}

criterion_main!(metrics_benchmarks);

#[cfg(test)]
mod metrics_validation {
    
    
    
    #[test]
    fn validate_observation_overhead() {
        let registry = MetricsRegistry::new();
        let iterations = 100000;
        
        let start = Instant::now();
        for i in 0..iterations {
            registry.observe_counter("test_counter".to_string(), i as f64);
        }
        let elapsed = start.elapsed();
        
        let avg_overhead_ns = elapsed.as_nanos() / iterations;
        let avg_overhead_us = avg_overhead_ns / 1000;
        
        println!("✓ Average observation overhead: {}ns ({}μs)", avg_overhead_ns, avg_overhead_us);
        
        // Target: <5μs = 5000ns
        assert!(
            avg_overhead_ns < 5000,
            "Observation overhead exceeds 5μs target: {}ns",
            avg_overhead_ns
        );
    }
    
    #[test]
    fn validate_registry_scalability() {
        let registry = MetricsRegistry::new();
        
        // Add many metrics
        for i in 0..10000 {
            registry.observe_counter(format!("metric_{}", i), 1.0);
        }
        
        // Measure lookup time with large registry
        let start = Instant::now();
        for _ in 0..1000 {
            registry.observe_counter("metric_5000".to_string(), 1.0);
        }
        let elapsed = start.elapsed();
        
        let avg_lookup_ns = elapsed.as_nanos() / 1000;
        
        println!(
            "✓ Registry with {} metrics, avg lookup: {}ns",
            registry.metric_count(),
            avg_lookup_ns
        );
        
        // Should maintain O(1) performance
        assert!(
            avg_lookup_ns < 10000,
            "Registry lookup degraded with size: {}ns",
            avg_lookup_ns
        );
    }
    
    #[test]
    fn validate_label_cardinality() {
        let max_labels = 20;
        let iterations = 10000;
        
        let start = Instant::now();
        for _ in 0..iterations {
            let mut labels = HashMap::new();
            for i in 0..max_labels {
                labels.insert(format!("label_{}", i), format!("value_{}", i));
            }
            
            let _observation = MetricObservation {
                name: "test_metric".to_string(),
                labels,
                value: 42.0,
                timestamp: 0,
            };
        }
        let elapsed = start.elapsed();
        
        let avg_time_ns = elapsed.as_nanos() / iterations;
        
        println!(
            "✓ {} labels per metric, avg creation time: {}ns",
            max_labels, avg_time_ns
        );
        
        // Should handle high cardinality efficiently
        assert!(
            avg_time_ns < 50000,
            "Label processing too slow: {}ns",
            avg_time_ns
        );
    }
    
    #[test]
    fn validate_aggregation_performance() {
        let sample_count = 10000;
        let samples: Vec<f64> = (0..sample_count).map(|i| i as f64).collect();
        
        let start = Instant::now();
        
        let mut sorted = samples.clone();
        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());
        
        let _p50 = sorted[sample_count / 2];
        let _p95 = sorted[(sample_count * 95) / 100];
        let _p99 = sorted[(sample_count * 99) / 100];
        
        let elapsed = start.elapsed();
        
        println!(
            "✓ Aggregated {} samples in {:?}",
            sample_count, elapsed
        );
        
        // Target: <100μs for aggregation
        assert!(
            elapsed < Duration::from_micros(100),
            "Aggregation too slow: {:?}",
            elapsed
        );
    }
}