Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

crates/ruvector-tiny-dancer-core/examples/full_observability.rs

@@ -0,0 +1,204 @@
+//! Comprehensive observability example demonstrating routing performance
+//!
+//! This example demonstrates:
+//! - Circuit breaker monitoring
+//! - Performance tracking
+//! - Response statistics
+//! - Different load scenarios
+//!
+//! Run with: cargo run --example full_observability
+
+use ruvector_tiny_dancer_core::{Candidate, Router, RouterConfig, RoutingRequest, RoutingResponse};
+use std::collections::HashMap;
+use std::time::Duration;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("=== Tiny Dancer Full Observability Example ===\n");
+
+    // Create router with full configuration
+    let config = RouterConfig {
+        model_path: "./models/fastgrnn.safetensors".to_string(),
+        confidence_threshold: 0.85,
+        max_uncertainty: 0.15,
+        enable_circuit_breaker: true,
+        circuit_breaker_threshold: 3,
+        enable_quantization: true,
+        database_path: None,
+    };
+
+    let router = Router::new(config)?;
+
+    // Track metrics manually
+    let mut total_requests = 0u64;
+    let mut successful_requests = 0u64;
+    let mut total_latency_us = 0u64;
+    let mut lightweight_routes = 0usize;
+    let mut powerful_routes = 0usize;
+
+    println!("\n=== Scenario 1: Normal Operations ===\n");
+
+    // Process normal requests
+    for i in 0..5 {
+        let candidates = create_candidates(i, 3);
+        let request = RoutingRequest {
+            query_embedding: vec![0.5 + (i as f32 * 0.05); 384],
+            candidates,
+            metadata: Some(HashMap::from([(
+                "scenario".to_string(),
+                serde_json::json!("normal_operations"),
+            )])),
+        };
+
+        total_requests += 1;
+        match router.route(request) {
+            Ok(response) => {
+                successful_requests += 1;
+                total_latency_us += response.inference_time_us;
+                let (lw, pw) = count_routes(&response);
+                lightweight_routes += lw;
+                powerful_routes += pw;
+                print_response_summary(i + 1, &response);
+            }
+            Err(e) => {
+                eprintln!("Request {} failed: {}", i + 1, e);
+            }
+        }
+
+        std::thread::sleep(Duration::from_millis(100));
+    }
+
+    println!("\n=== Scenario 2: High Load ===\n");
+
+    // Simulate high load with many candidates
+    for i in 0..3 {
+        let candidates = create_candidates(i, 20); // More candidates
+        let request = RoutingRequest {
+            query_embedding: vec![0.6; 384],
+            candidates,
+            metadata: Some(HashMap::from([(
+                "scenario".to_string(),
+                serde_json::json!("high_load"),
+            )])),
+        };
+
+        total_requests += 1;
+        match router.route(request) {
+            Ok(response) => {
+                successful_requests += 1;
+                total_latency_us += response.inference_time_us;
+                let (lw, pw) = count_routes(&response);
+                lightweight_routes += lw;
+                powerful_routes += pw;
+                print_response_summary(i + 1, &response);
+            }
+            Err(e) => {
+                eprintln!("Request {} failed: {}", i + 1, e);
+            }
+        }
+    }
+
+    // Display statistics
+    println!("\n=== Performance Statistics ===\n");
+    display_statistics(
+        total_requests,
+        successful_requests,
+        total_latency_us,
+        lightweight_routes,
+        powerful_routes,
+        &router,
+    );
+
+    println!("\n=== Full Observability Example Complete ===");
+    println!("\nMetrics Summary:");
+    println!("- Total requests processed");
+    println!("- Success/failure rates tracked");
+    println!("- Latency statistics computed");
+    println!("- Routing decisions categorized");
+    println!("- Circuit breaker state monitored");
+
+    Ok(())
+}
+
+fn create_candidates(offset: i32, count: usize) -> Vec<Candidate> {
+    (0..count)
+        .map(|i| {
+            let base_score = 0.7 + ((i + offset as usize) as f32 * 0.02) % 0.3;
+            Candidate {
+                id: format!("candidate-{}-{}", offset, i),
+                embedding: vec![base_score; 384],
+                metadata: HashMap::new(),
+                created_at: chrono::Utc::now().timestamp(),
+                access_count: 10 + i as u64,
+                success_rate: 0.85 + (base_score * 0.15),
+            }
+        })
+        .collect()
+}
+
+fn count_routes(response: &RoutingResponse) -> (usize, usize) {
+    let lightweight = response
+        .decisions
+        .iter()
+        .filter(|d| d.use_lightweight)
+        .count();
+    let powerful = response.decisions.len() - lightweight;
+    (lightweight, powerful)
+}
+
+fn print_response_summary(request_num: i32, response: &RoutingResponse) {
+    let (lightweight_count, powerful_count) = count_routes(response);
+
+    println!(
+        "Request {}: {}μs total, {}μs features, {} candidates",
+        request_num,
+        response.inference_time_us,
+        response.feature_time_us,
+        response.candidates_processed
+    );
+    println!(
+        "  Routing: {} lightweight, {} powerful",
+        lightweight_count, powerful_count
+    );
+
+    if let Some(top_decision) = response.decisions.first() {
+        println!(
+            "  Top: {} (confidence: {:.3}, uncertainty: {:.3})",
+            top_decision.candidate_id, top_decision.confidence, top_decision.uncertainty
+        );
+    }
+}
+
+fn display_statistics(
+    total_requests: u64,
+    successful_requests: u64,
+    total_latency_us: u64,
+    lightweight_routes: usize,
+    powerful_routes: usize,
+    router: &Router,
+) {
+    let cb_state = match router.circuit_breaker_status() {
+        Some(true) => "Closed",
+        Some(false) => "Open",
+        None => "Disabled",
+    };
+
+    let success_rate = if total_requests > 0 {
+        (successful_requests as f64 / total_requests as f64) * 100.0
+    } else {
+        0.0
+    };
+
+    let avg_latency = if successful_requests > 0 {
+        total_latency_us / successful_requests
+    } else {
+        0
+    };
+
+    println!("Circuit Breaker: {}", cb_state);
+    println!("Total Requests: {}", total_requests);
+    println!("Successful Requests: {}", successful_requests);
+    println!("Success Rate: {:.1}%", success_rate);
+    println!("Avg Latency: {}μs", avg_latency);
+    println!("Lightweight Routes: {}", lightweight_routes);
+    println!("Powerful Routes: {}", powerful_routes);
+}