foxhunt/services/api_gateway/examples/metrics_example.rs

//! Metrics Integration Example
//!
//! Demonstrates how to integrate Prometheus metrics into the API Gateway

use api_gateway::metrics::{GatewayMetrics, metrics_router};
use tokio::net::TcpListener;
use std::time::Instant;
use std::net::SocketAddr;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 API Gateway Metrics Example");
    println!("=====================================\n");

    // Initialize metrics
    println!("1. Initializing metrics registry...");
    let metrics = GatewayMetrics::new()?;
    println!("   ✅ Metrics registry created with {} subsystems\n", 3);

    // Simulate authentication events
    println!("2. Recording authentication events...");

    // Successful auth
    for i in 0..100 {
        let start = Instant::now();

        // Simulate JWT extraction (0.5μs)
        std::thread::sleep(std::time::Duration::from_nanos(500));
        metrics.auth.jwt_extraction_duration_us.observe(0.5);

        // Simulate JWT validation (0.8μs)
        std::thread::sleep(std::time::Duration::from_nanos(800));
        metrics.auth.jwt_validation_duration_us.observe(0.8);

        // Simulate revocation check (0.3μs)
        std::thread::sleep(std::time::Duration::from_nanos(300));
        metrics.auth.revocation_check_duration_us.observe(0.3);

        // Simulate RBAC check (0.1μs)
        std::thread::sleep(std::time::Duration::from_nanos(100));
        metrics.auth.rbac_check_duration_us.observe(0.1);

        // Simulate rate limit check (0.05μs)
        std::thread::sleep(std::time::Duration::from_nanos(50));
        metrics.auth.rate_limit_check_duration_us.observe(0.05);

        let total_duration_us = start.elapsed().as_nanos() as f64 / 1000.0;
        metrics.auth.record_success(total_duration_us);
        metrics.auth.record_user_request(&format!("user_{}", i % 10));

        if i % 10 == 0 {
            println!("   ✅ Recorded {} successful auth requests", i + 1);
        }
    }

    // Simulate auth failures
    println!("\n3. Recording authentication failures...");
    metrics.auth.record_failure("expired_jwt", Some("user_99"));
    metrics.auth.record_failure("revoked_jwt", Some("user_88"));
    metrics.auth.record_failure("permission_denied", Some("user_77"));
    metrics.auth.record_rate_limit("user_66");
    println!("   ✅ Recorded 4 auth failures\n");

    // Simulate backend proxy events
    println!("4. Recording backend proxy events...");

    // Trading service requests
    for i in 0..50 {
        metrics.proxy.record_backend_success("trading", "ExecuteTrade", 15.5);
        if i % 10 == 0 {
            println!("   ✅ Recorded {} trading service requests", i + 1);
        }
    }

    // Backtesting service requests
    for i in 0..30 {
        metrics.proxy.record_backend_success("backtesting", "RunBacktest", 250.0);
    }
    println!("   ✅ Recorded 30 backtesting service requests");

    // ML Training service requests
    metrics.proxy.record_backend_success("ml_training", "TrainModel", 5000.0);
    println!("   ✅ Recorded ML training requests\n");

    // Update health status
    println!("5. Updating service health status...");
    metrics.proxy.update_health_status("trading", true);
    metrics.proxy.update_health_status("backtesting", true);
    metrics.proxy.update_health_status("ml_training", true);
    println!("   ✅ All services healthy\n");

    // Update connection pools
    println!("6. Updating connection pool metrics...");
    metrics.proxy.update_connection_pool("trading", 10, 5, 50);
    metrics.proxy.update_connection_pool("backtesting", 3, 7, 20);
    metrics.proxy.update_connection_pool("ml_training", 2, 8, 10);
    println!("   ✅ Connection pool stats updated\n");

    // Simulate configuration events
    println!("7. Recording configuration events...");
    metrics.config.record_notify_event(true);
    metrics.config.record_config_reload("auth", 25.0);
    metrics.config.record_config_reload("routing", 18.5);
    metrics.config.update_listener_status(true);
    println!("   ✅ Configuration hot-reload events recorded\n");

    // Update cache metrics
    println!("8. Recording cache performance...");
    metrics.auth.jwt_cache_hits.inc_by(950.0);
    metrics.auth.jwt_cache_misses.inc_by(50.0);
    metrics.auth.rbac_cache_hits.inc_by(980.0);
    metrics.auth.rbac_cache_misses.inc_by(20.0);
    metrics.config.config_cache_hits.inc_by(1500.0);
    metrics.config.config_cache_misses.inc_by(100.0);
    println!("   ✅ Cache hit/miss stats updated\n");

    // Print metrics summary
    println!("📊 Metrics Summary");
    println!("=====================================");
    println!("Auth Metrics:");
    println!("  - Requests: 100 success, 4 failures");
    println!("  - JWT Cache Hit Rate: 95%");
    println!("  - RBAC Cache Hit Rate: 98%");
    println!("\nProxy Metrics:");
    println!("  - Trading Service: 50 requests, 15.5ms avg");
    println!("  - Backtesting Service: 30 requests, 250ms avg");
    println!("  - ML Training Service: 1 request, 5000ms");
    println!("\nConfig Metrics:");
    println!("  - NOTIFY events: 1 processed");
    println!("  - Config reloads: 2 (auth, routing)");
    println!("  - Config Cache Hit Rate: 93.75%");
    println!("\n");

    // Start Prometheus exporter
    println!("9. Starting Prometheus metrics exporter...");
    let router = metrics_router(metrics.registry());
    let addr = SocketAddr::from(([127, 0, 0, 1], 9090));

    println!("   ✅ Metrics available at http://{}/metrics\n", addr);
    println!("📡 Exporting metrics to Prometheus...");
    println!("   Press Ctrl+C to stop\n");

    let listener = TcpListener::bind(&addr).await?;
    axum::serve(listener, router).await?;

    Ok(())
}