oxideshield_guard/telemetry/

recorder.rs

//! Metrics Recording
//!
//! Provides wrappers and utilities for recording guard metrics.

use std::sync::Arc;
use std::time::Instant;

use super::metrics::{global_metrics, GuardMetricsCollector};
use crate::guard::{Guard, GuardAction, GuardCheckResult};

/// A guard wrapper that records metrics
pub struct InstrumentedGuard<G: Guard> {
    inner: G,
    collector: Arc<GuardMetricsCollector>,
    /// Guard type name for per-type metrics breakdown
    guard_type: String,
}

impl<G: Guard> InstrumentedGuard<G> {
    /// Create a new instrumented guard using the global collector
    pub fn new(guard: G) -> Self {
        Self::with_collector(guard, global_metrics())
    }

    /// Create a new instrumented guard with a specific collector
    pub fn with_collector(guard: G, collector: Arc<GuardMetricsCollector>) -> Self {
        Self {
            guard_type: std::any::type_name::<G>().to_string(),
            inner: guard,
            collector,
        }
    }

    /// Get a reference to the inner guard
    pub fn inner(&self) -> &G {
        &self.inner
    }

    /// Get the collector
    pub fn collector(&self) -> Arc<GuardMetricsCollector> {
        self.collector.clone()
    }
}

impl<G: Guard> Guard for InstrumentedGuard<G> {
    fn name(&self) -> &str {
        self.inner.name()
    }

    fn action(&self) -> crate::guard::GuardAction {
        self.inner.action()
    }

    fn check(&self, content: &str) -> GuardCheckResult {
        self.collector.record_check_started();
        let start = Instant::now();

        let result = self.inner.check(content);

        let elapsed = start.elapsed();
        let sanitized = matches!(result.action, GuardAction::Sanitize);

        // Record metrics with both guard name and type for per-type breakdown
        self.collector.record_check_completed_with_type(
            self.inner.name(),
            &self.guard_type,
            result.passed,
            sanitized,
            elapsed,
        );

        result
    }
}

impl<G: Guard> InstrumentedGuard<G> {
    /// Get the guard type name
    pub fn guard_type(&self) -> &str {
        &self.guard_type
    }
}

/// Extension trait for adding instrumentation to guards
pub trait InstrumentGuard: Guard + Sized {
    /// Wrap this guard with metrics instrumentation
    fn instrumented(self) -> InstrumentedGuard<Self> {
        InstrumentedGuard::new(self)
    }

    /// Wrap this guard with a specific collector
    fn instrumented_with(self, collector: Arc<GuardMetricsCollector>) -> InstrumentedGuard<Self> {
        InstrumentedGuard::with_collector(self, collector)
    }
}

// Implement for all guards
impl<G: Guard + Sized> InstrumentGuard for G {}

/// Metrics snapshot
#[derive(Debug, Clone)]
pub struct MetricsSnapshot {
    /// Total checks
    pub total_checks: u64,
    /// Total blocks
    pub total_blocks: u64,
    /// Total passed
    pub total_passed: u64,
    /// Block rate
    pub block_rate: f64,
    /// Average latency
    pub avg_latency_ms: f64,
    /// P50 latency
    pub p50_latency_ms: f64,
    /// P99 latency
    pub p99_latency_ms: f64,
    /// Timestamp
    pub timestamp: chrono::DateTime<chrono::Utc>,
}

impl MetricsSnapshot {
    /// Take a snapshot from a collector
    pub fn from_collector(collector: &GuardMetricsCollector) -> Self {
        Self {
            total_checks: collector.total_checks(),
            total_blocks: collector.total_blocks(),
            total_passed: collector.total_passed(),
            block_rate: collector.block_rate(),
            avg_latency_ms: collector.avg_latency_ms(),
            p50_latency_ms: collector.p50_latency_ms(),
            p99_latency_ms: collector.p99_latency_ms(),
            timestamp: chrono::Utc::now(),
        }
    }

    /// Take a snapshot from global metrics
    pub fn global() -> Self {
        Self::from_collector(&global_metrics())
    }
}

/// Metrics reporter for periodic reporting
pub struct MetricsReporter {
    collector: Arc<GuardMetricsCollector>,
    last_snapshot: parking_lot::RwLock<Option<MetricsSnapshot>>,
}

impl MetricsReporter {
    /// Create a new reporter
    pub fn new(collector: Arc<GuardMetricsCollector>) -> Self {
        Self {
            collector,
            last_snapshot: parking_lot::RwLock::new(None),
        }
    }

    /// Create a reporter using global metrics
    pub fn global() -> Self {
        Self::new(global_metrics())
    }

    /// Get current metrics
    pub fn current(&self) -> MetricsSnapshot {
        MetricsSnapshot::from_collector(&self.collector)
    }

    /// Get delta since last report
    pub fn delta(&self) -> MetricsDelta {
        let current = self.current();
        let last = self.last_snapshot.read().clone();

        let delta = if let Some(ref last) = last {
            MetricsDelta {
                checks: current.total_checks.saturating_sub(last.total_checks),
                blocks: current.total_blocks.saturating_sub(last.total_blocks),
                passed: current.total_passed.saturating_sub(last.total_passed),
                duration: current.timestamp - last.timestamp,
            }
        } else {
            MetricsDelta {
                checks: current.total_checks,
                blocks: current.total_blocks,
                passed: current.total_passed,
                duration: chrono::Duration::zero(),
            }
        };

        *self.last_snapshot.write() = Some(current);
        delta
    }

    /// Get throughput (checks per second) since last report
    pub fn throughput(&self) -> f64 {
        let delta = self.delta();
        let seconds = delta.duration.num_milliseconds() as f64 / 1000.0;
        if seconds > 0.0 {
            delta.checks as f64 / seconds
        } else {
            0.0
        }
    }
}

/// Delta between metric snapshots
#[derive(Debug, Clone)]
pub struct MetricsDelta {
    /// Checks since last snapshot
    pub checks: u64,
    /// Blocks since last snapshot
    pub blocks: u64,
    /// Passed since last snapshot
    pub passed: u64,
    /// Time since last snapshot
    pub duration: chrono::Duration,
}

impl MetricsDelta {
    /// Get block rate for this period
    pub fn block_rate(&self) -> f64 {
        if self.checks == 0 {
            0.0
        } else {
            self.blocks as f64 / self.checks as f64
        }
    }

    /// Get checks per second for this period
    pub fn checks_per_second(&self) -> f64 {
        let seconds = self.duration.num_milliseconds() as f64 / 1000.0;
        if seconds > 0.0 {
            self.checks as f64 / seconds
        } else {
            0.0
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::guard::LengthGuard;

    #[test]
    fn test_instrumented_guard() {
        let collector = GuardMetricsCollector::shared();
        let guard = LengthGuard::new("length")
            .with_max_chars(100)
            .instrumented_with(collector.clone());

        let result = guard.check("short text");
        assert!(result.passed);

        assert_eq!(collector.total_checks(), 1);
        assert_eq!(collector.total_passed(), 1);
    }

    #[test]
    fn test_instrumented_guard_blocked() {
        let collector = GuardMetricsCollector::shared();
        let guard = LengthGuard::new("length")
            .with_max_chars(5)
            .instrumented_with(collector.clone());

        let result = guard.check("this is too long");
        assert!(!result.passed);

        assert_eq!(collector.total_blocks(), 1);
    }

    #[test]
    fn test_metrics_snapshot() {
        let collector = GuardMetricsCollector::new();
        collector.record_check_completed("test", true, false, std::time::Duration::from_millis(10));

        let snapshot = MetricsSnapshot::from_collector(&collector);
        assert_eq!(snapshot.total_checks, 1);
        assert_eq!(snapshot.total_passed, 1);
    }

    #[test]
    fn test_metrics_reporter() {
        let collector = GuardMetricsCollector::shared();
        let reporter = MetricsReporter::new(collector.clone());

        // Initial delta
        let delta = reporter.delta();
        assert_eq!(delta.checks, 0);

        // Add some checks
        for _ in 0..5 {
            collector.record_check_completed(
                "test",
                true,
                false,
                std::time::Duration::from_millis(10),
            );
        }

        // Get new delta
        let delta = reporter.delta();
        assert_eq!(delta.checks, 5);
    }

    #[test]
    fn test_instrument_trait() {
        let guard = LengthGuard::new("length")
            .with_max_chars(100)
            .instrumented();

        // Just verify it compiles and works
        let result = guard.check("test");
        assert!(result.passed);
    }

    #[test]
    fn test_per_type_metrics() {
        let collector = GuardMetricsCollector::shared();

        // Record checks with type info
        collector.record_check_completed_with_type(
            "guard_a",
            "oxideshield_guard::guards::length::LengthGuard",
            true,
            false,
            std::time::Duration::from_millis(5),
        );
        collector.record_check_completed_with_type(
            "guard_b",
            "oxideshield_guard::guards::length::LengthGuard",
            false,
            false,
            std::time::Duration::from_millis(10),
        );
        collector.record_check_completed_with_type(
            "guard_c",
            "oxideshield_guard::guards::pii::PIIGuard",
            true,
            false,
            std::time::Duration::from_millis(15),
        );

        // Verify per-guard metrics
        let per_guard = collector.per_guard_metrics();
        assert!(per_guard.contains_key("guard_a"));
        assert!(per_guard.contains_key("guard_b"));
        assert!(per_guard.contains_key("guard_c"));

        // Verify per-type metrics (aggregated by type)
        let per_type = collector.per_type_metrics();
        assert!(per_type.contains_key("oxideshield_guard::guards::length::LengthGuard"));
        assert!(per_type.contains_key("oxideshield_guard::guards::pii::PIIGuard"));

        // LengthGuard type should have 2 checks
        let length_type = &per_type["oxideshield_guard::guards::length::LengthGuard"];
        assert_eq!(length_type.checks, 2);
        assert_eq!(length_type.passed, 1);
        assert_eq!(length_type.blocks, 1);

        // PIIGuard type should have 1 check
        let pii_type = &per_type["oxideshield_guard::guards::pii::PIIGuard"];
        assert_eq!(pii_type.checks, 1);
        assert_eq!(pii_type.passed, 1);
    }

    #[test]
    fn test_instrumented_guard_records_type() {
        let collector = GuardMetricsCollector::shared();
        collector.reset();

        let guard = LengthGuard::new("typed_length")
            .with_max_chars(100)
            .instrumented_with(collector.clone());

        // Verify guard type is captured
        assert!(guard.guard_type().contains("LengthGuard"));

        // Run a check
        guard.check("test text");

        // Verify per-type metrics recorded
        let per_type = collector.per_type_metrics();
        assert!(!per_type.is_empty(), "Should have per-type metrics");

        // Find the LengthGuard type entry
        let has_length_type = per_type.keys().any(|k| k.contains("LengthGuard"));
        assert!(has_length_type, "Should have LengthGuard type metrics");
    }
}