@llm-dev-ops/agentics-cli 1.4.27 → 1.4.29

package/dist/bundled-agents/memory-graph-agents/src/observatory/prometheus.rs

@@ -1,1296 +0,0 @@
-//! Prometheus metrics integration for real-time monitoring
-//!
-//! This module provides comprehensive production-grade Prometheus metrics for monitoring
-//! memory graph operations, performance, resource utilization, and integrations.
-//!
-//! # Metrics Categories
-//!
-//! ## Core Metrics
-//! - **Counters**: Track cumulative counts of operations (nodes, edges, prompts, etc.)
-//! - **Histograms**: Measure latency distributions and batch sizes
-//! - **Gauges**: Monitor current state and resource utilization
-//!
-//! ## Production Metrics
-//! - **gRPC Metrics**: Request counts, durations, and active streams
-//! - **Plugin Metrics**: Plugin executions, durations, and error tracking
-//! - **Integration Metrics**: LLM-Registry calls and Data-Vault operations
-//!
-//! # Examples
-//!
-//! ## Basic Usage
-//!
-//! ```no_run
-//! use llm_memory_graph::observatory::prometheus::PrometheusMetrics;
-//! use prometheus::Registry;
-//!
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! let registry = Registry::new();
-//! let metrics = PrometheusMetrics::new(&registry)?;
-//!
-//! // Record core operations
-//! metrics.record_node_created();
-//! metrics.record_write_latency(0.025);
-//! metrics.set_active_sessions(5);
-//!
-//! // Export metrics
-//! let metrics_text = prometheus::TextEncoder::new()
-//!     .encode_to_string(&registry.gather())?;
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! ## Production Metrics Usage
-//!
-//! ```no_run
-//! # use llm_memory_graph::observatory::prometheus::PrometheusMetrics;
-//! # use prometheus::Registry;
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! # let registry = Registry::new();
-//! # let metrics = PrometheusMetrics::new(&registry)?;
-//! // Record gRPC operations
-//! metrics.record_grpc_request("CreateSession", "success");
-//! metrics.record_grpc_request_duration("CreateSession", 0.015);
-//! metrics.inc_grpc_active_streams();
-//!
-//! // Record plugin operations
-//! metrics.record_plugin_execution("audit_logger", "on_node_create");
-//! metrics.record_plugin_duration("audit_logger", "on_node_create", 0.002);
-//! metrics.record_plugin_error("validator", "validation_failed");
-//!
-//! // Record integration operations
-//! metrics.record_registry_call("register_model", "success");
-//! metrics.record_vault_archive();
-//! metrics.record_vault_retrieval();
-//! # Ok(())
-//! # }
-//! ```
-
-use crate::error::Result;
-use prometheus::{
-    Histogram, HistogramOpts, HistogramVec, IntCounter, IntCounterVec, IntGauge, Opts, Registry,
-};
-
-/// Prometheus metrics for MemoryGraph monitoring
-///
-/// Provides comprehensive production-grade metrics across multiple categories:
-/// - 8 Counters for tracking operations
-/// - 5 Histograms for latency and size distributions
-/// - 5 Gauges for current state monitoring
-/// - 7 Production metrics (gRPC, Plugin, Integration)
-#[derive(Clone)]
-pub struct PrometheusMetrics {
-    // Counters - Track cumulative counts
-    /// Total number of nodes created
-    pub nodes_created: IntCounter,
-    /// Total number of edges created
-    pub edges_created: IntCounter,
-    /// Total number of prompts submitted
-    pub prompts_submitted: IntCounter,
-    /// Total number of responses generated
-    pub responses_generated: IntCounter,
-    /// Total number of tools invoked
-    pub tools_invoked: IntCounter,
-    /// Total number of agent handoffs
-    pub agent_handoffs: IntCounter,
-    /// Total number of template instantiations
-    pub template_instantiations: IntCounter,
-    /// Total number of queries executed
-    pub queries_executed: IntCounter,
-
-    // Histograms - Measure distributions
-    /// Write operation latency distribution (seconds)
-    pub write_latency: Histogram,
-    /// Read operation latency distribution (seconds)
-    pub read_latency: Histogram,
-    /// Query execution duration distribution (seconds)
-    pub query_duration: Histogram,
-    /// Tool execution duration distribution (seconds)
-    pub tool_duration: Histogram,
-    /// Batch operation size distribution
-    pub batch_size: Histogram,
-
-    // Gauges - Current state metrics
-    /// Number of currently active sessions
-    pub active_sessions: IntGauge,
-    /// Total number of nodes in the graph
-    pub total_nodes: IntGauge,
-    /// Total number of edges in the graph
-    pub total_edges: IntGauge,
-    /// Current cache size in bytes
-    pub cache_size_bytes: IntGauge,
-    /// Current event buffer size
-    pub buffer_size: IntGauge,
-
-    // Production Metrics - gRPC
-    /// Total gRPC requests by method and status
-    pub grpc_requests_total: IntCounterVec,
-    /// gRPC request duration by method
-    pub grpc_request_duration: HistogramVec,
-    /// Number of active gRPC streams
-    pub grpc_active_streams: IntGauge,
-
-    // Production Metrics - Plugin System
-    /// Total plugin executions by plugin name and hook
-    pub plugin_executions_total: IntCounterVec,
-    /// Plugin execution duration by plugin and hook
-    pub plugin_duration: HistogramVec,
-    /// Total plugin errors by plugin and error type
-    pub plugin_errors_total: IntCounterVec,
-
-    // Production Metrics - Integrations
-    /// Total LLM-Registry API calls by operation and status
-    pub registry_calls_total: IntCounterVec,
-    /// Total sessions archived to Data-Vault
-    pub vault_archives_total: IntCounter,
-    /// Total sessions retrieved from Data-Vault
-    pub vault_retrievals_total: IntCounter,
-    /// Total Data-Vault errors
-    pub vault_errors_total: IntCounter,
-}
-
-impl PrometheusMetrics {
-    /// Create and register all metrics with the provided registry
-    ///
-    /// # Arguments
-    ///
-    /// * `registry` - Prometheus registry to register metrics with
-    ///
-    /// # Returns
-    ///
-    /// Returns a new PrometheusMetrics instance with all metrics registered
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if metric registration fails
-    pub fn new(registry: &Registry) -> Result<Self> {
-        // Counters
-        let nodes_created = IntCounter::with_opts(Opts::new(
-            "memory_graph_nodes_created_total",
-            "Total number of nodes created in the memory graph",
-        ))?;
-        registry.register(Box::new(nodes_created.clone()))?;
-
-        let edges_created = IntCounter::with_opts(Opts::new(
-            "memory_graph_edges_created_total",
-            "Total number of edges created in the memory graph",
-        ))?;
-        registry.register(Box::new(edges_created.clone()))?;
-
-        let prompts_submitted = IntCounter::with_opts(Opts::new(
-            "memory_graph_prompts_submitted_total",
-            "Total number of prompts submitted",
-        ))?;
-        registry.register(Box::new(prompts_submitted.clone()))?;
-
-        let responses_generated = IntCounter::with_opts(Opts::new(
-            "memory_graph_responses_generated_total",
-            "Total number of responses generated",
-        ))?;
-        registry.register(Box::new(responses_generated.clone()))?;
-
-        let tools_invoked = IntCounter::with_opts(Opts::new(
-            "memory_graph_tools_invoked_total",
-            "Total number of tools invoked",
-        ))?;
-        registry.register(Box::new(tools_invoked.clone()))?;
-
-        let agent_handoffs = IntCounter::with_opts(Opts::new(
-            "memory_graph_agent_handoffs_total",
-            "Total number of agent handoffs",
-        ))?;
-        registry.register(Box::new(agent_handoffs.clone()))?;
-
-        let template_instantiations = IntCounter::with_opts(Opts::new(
-            "memory_graph_template_instantiations_total",
-            "Total number of template instantiations",
-        ))?;
-        registry.register(Box::new(template_instantiations.clone()))?;
-
-        let queries_executed = IntCounter::with_opts(Opts::new(
-            "memory_graph_queries_executed_total",
-            "Total number of queries executed",
-        ))?;
-        registry.register(Box::new(queries_executed.clone()))?;
-
-        // Histograms with appropriate buckets
-        let write_latency = Histogram::with_opts(
-            HistogramOpts::new(
-                "memory_graph_write_latency_seconds",
-                "Write operation latency in seconds",
-            )
-            .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0]),
-        )?;
-        registry.register(Box::new(write_latency.clone()))?;
-
-        let read_latency = Histogram::with_opts(
-            HistogramOpts::new(
-                "memory_graph_read_latency_seconds",
-                "Read operation latency in seconds",
-            )
-            .buckets(vec![0.0001, 0.0005, 0.001, 0.005, 0.01, 0.025, 0.05, 0.1]),
-        )?;
-        registry.register(Box::new(read_latency.clone()))?;
-
-        let query_duration = Histogram::with_opts(
-            HistogramOpts::new(
-                "memory_graph_query_duration_seconds",
-                "Query execution duration in seconds",
-            )
-            .buckets(vec![0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]),
-        )?;
-        registry.register(Box::new(query_duration.clone()))?;
-
-        let tool_duration = Histogram::with_opts(
-            HistogramOpts::new(
-                "memory_graph_tool_duration_seconds",
-                "Tool execution duration in seconds",
-            )
-            .buckets(vec![0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0, 60.0]),
-        )?;
-        registry.register(Box::new(tool_duration.clone()))?;
-
-        let batch_size = Histogram::with_opts(
-            HistogramOpts::new(
-                "memory_graph_batch_size",
-                "Batch operation size distribution",
-            )
-            .buckets(vec![
-                1.0, 5.0, 10.0, 25.0, 50.0, 100.0, 250.0, 500.0, 1000.0,
-            ]),
-        )?;
-        registry.register(Box::new(batch_size.clone()))?;
-
-        // Gauges
-        let active_sessions = IntGauge::with_opts(Opts::new(
-            "memory_graph_active_sessions",
-            "Number of currently active sessions",
-        ))?;
-        registry.register(Box::new(active_sessions.clone()))?;
-
-        let total_nodes = IntGauge::with_opts(Opts::new(
-            "memory_graph_total_nodes",
-            "Total number of nodes in the graph",
-        ))?;
-        registry.register(Box::new(total_nodes.clone()))?;
-
-        let total_edges = IntGauge::with_opts(Opts::new(
-            "memory_graph_total_edges",
-            "Total number of edges in the graph",
-        ))?;
-        registry.register(Box::new(total_edges.clone()))?;
-
-        let cache_size_bytes = IntGauge::with_opts(Opts::new(
-            "memory_graph_cache_size_bytes",
-            "Current cache size in bytes",
-        ))?;
-        registry.register(Box::new(cache_size_bytes.clone()))?;
-
-        let buffer_size = IntGauge::with_opts(Opts::new(
-            "memory_graph_buffer_size",
-            "Current event buffer size",
-        ))?;
-        registry.register(Box::new(buffer_size.clone()))?;
-
-        // Production Metrics - gRPC
-        let grpc_requests_total = IntCounterVec::new(
-            Opts::new(
-                "memory_graph_grpc_requests_total",
-                "Total number of gRPC requests by method and status",
-            ),
-            &["method", "status"],
-        )?;
-        registry.register(Box::new(grpc_requests_total.clone()))?;
-
-        let grpc_request_duration = HistogramVec::new(
-            HistogramOpts::new(
-                "memory_graph_grpc_request_duration_seconds",
-                "gRPC request duration in seconds by method",
-            )
-            .buckets(vec![0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0]),
-            &["method"],
-        )?;
-        registry.register(Box::new(grpc_request_duration.clone()))?;
-
-        let grpc_active_streams = IntGauge::with_opts(Opts::new(
-            "memory_graph_grpc_active_streams",
-            "Number of active gRPC streams",
-        ))?;
-        registry.register(Box::new(grpc_active_streams.clone()))?;
-
-        // Production Metrics - Plugin System
-        let plugin_executions_total = IntCounterVec::new(
-            Opts::new(
-                "memory_graph_plugin_executions_total",
-                "Total plugin executions by plugin name and hook",
-            ),
-            &["plugin", "hook"],
-        )?;
-        registry.register(Box::new(plugin_executions_total.clone()))?;
-
-        let plugin_duration = HistogramVec::new(
-            HistogramOpts::new(
-                "memory_graph_plugin_duration_seconds",
-                "Plugin execution duration in seconds",
-            )
-            .buckets(vec![0.001, 0.01, 0.1, 1.0, 5.0, 10.0]),
-            &["plugin", "hook"],
-        )?;
-        registry.register(Box::new(plugin_duration.clone()))?;
-
-        let plugin_errors_total = IntCounterVec::new(
-            Opts::new(
-                "memory_graph_plugin_errors_total",
-                "Total plugin errors by plugin and error type",
-            ),
-            &["plugin", "error_type"],
-        )?;
-        registry.register(Box::new(plugin_errors_total.clone()))?;
-
-        // Production Metrics - Integrations
-        let registry_calls_total = IntCounterVec::new(
-            Opts::new(
-                "memory_graph_registry_calls_total",
-                "Total LLM-Registry API calls by operation and status",
-            ),
-            &["operation", "status"],
-        )?;
-        registry.register(Box::new(registry_calls_total.clone()))?;
-
-        let vault_archives_total = IntCounter::with_opts(Opts::new(
-            "memory_graph_vault_archives_total",
-            "Total sessions archived to Data-Vault",
-        ))?;
-        registry.register(Box::new(vault_archives_total.clone()))?;
-
-        let vault_retrievals_total = IntCounter::with_opts(Opts::new(
-            "memory_graph_vault_retrievals_total",
-            "Total sessions retrieved from Data-Vault",
-        ))?;
-        registry.register(Box::new(vault_retrievals_total.clone()))?;
-
-        let vault_errors_total = IntCounter::with_opts(Opts::new(
-            "memory_graph_vault_errors_total",
-            "Total Data-Vault operation errors",
-        ))?;
-        registry.register(Box::new(vault_errors_total.clone()))?;
-
-        Ok(Self {
-            nodes_created,
-            edges_created,
-            prompts_submitted,
-            responses_generated,
-            tools_invoked,
-            agent_handoffs,
-            template_instantiations,
-            queries_executed,
-            write_latency,
-            read_latency,
-            query_duration,
-            tool_duration,
-            batch_size,
-            active_sessions,
-            total_nodes,
-            total_edges,
-            cache_size_bytes,
-            buffer_size,
-            grpc_requests_total,
-            grpc_request_duration,
-            grpc_active_streams,
-            plugin_executions_total,
-            plugin_duration,
-            plugin_errors_total,
-            registry_calls_total,
-            vault_archives_total,
-            vault_retrievals_total,
-            vault_errors_total,
-        })
-    }
-
-    /// Create metrics with a custom namespace prefix
-    pub fn with_namespace(registry: &Registry, _namespace: &str) -> Result<Self> {
-        // This is a simplified version - in production you'd apply prefix to all metrics
-        Self::new(registry)
-    }
-
-    // Counter recording methods
-
-    /// Record a node creation
-    pub fn record_node_created(&self) {
-        self.nodes_created.inc();
-    }
-
-    /// Record multiple node creations
-    pub fn record_nodes_created(&self, count: u64) {
-        self.nodes_created.inc_by(count);
-    }
-
-    /// Record an edge creation
-    pub fn record_edge_created(&self) {
-        self.edges_created.inc();
-    }
-
-    /// Record multiple edge creations
-    pub fn record_edges_created(&self, count: u64) {
-        self.edges_created.inc_by(count);
-    }
-
-    /// Record a prompt submission
-    pub fn record_prompt_submitted(&self) {
-        self.prompts_submitted.inc();
-    }
-
-    /// Record a response generation
-    pub fn record_response_generated(&self) {
-        self.responses_generated.inc();
-    }
-
-    /// Record a tool invocation
-    pub fn record_tool_invoked(&self) {
-        self.tools_invoked.inc();
-    }
-
-    /// Record an agent handoff
-    pub fn record_agent_handoff(&self) {
-        self.agent_handoffs.inc();
-    }
-
-    /// Record a template instantiation
-    pub fn record_template_instantiation(&self) {
-        self.template_instantiations.inc();
-    }
-
-    /// Record a query execution
-    pub fn record_query_executed(&self) {
-        self.queries_executed.inc();
-    }
-
-    // Histogram recording methods
-
-    /// Record write operation latency in seconds
-    pub fn record_write_latency(&self, duration_secs: f64) {
-        self.write_latency.observe(duration_secs);
-    }
-
-    /// Record read operation latency in seconds
-    pub fn record_read_latency(&self, duration_secs: f64) {
-        self.read_latency.observe(duration_secs);
-    }
-
-    /// Record query execution duration in seconds
-    pub fn record_query_duration(&self, duration_secs: f64) {
-        self.query_duration.observe(duration_secs);
-    }
-
-    /// Record tool execution duration in seconds
-    pub fn record_tool_duration(&self, duration_secs: f64) {
-        self.tool_duration.observe(duration_secs);
-    }
-
-    /// Record batch operation size
-    pub fn record_batch_size(&self, size: usize) {
-        self.batch_size.observe(size as f64);
-    }
-
-    // Gauge update methods
-
-    /// Set the number of active sessions
-    pub fn set_active_sessions(&self, count: i64) {
-        self.active_sessions.set(count);
-    }
-
-    /// Increment active sessions count
-    pub fn inc_active_sessions(&self) {
-        self.active_sessions.inc();
-    }
-
-    /// Decrement active sessions count
-    pub fn dec_active_sessions(&self) {
-        self.active_sessions.dec();
-    }
-
-    /// Set the total number of nodes
-    pub fn set_total_nodes(&self, count: i64) {
-        self.total_nodes.set(count);
-    }
-
-    /// Increment total nodes count
-    pub fn inc_total_nodes(&self) {
-        self.total_nodes.inc();
-    }
-
-    /// Increment total nodes by amount
-    pub fn inc_total_nodes_by(&self, count: i64) {
-        self.total_nodes.add(count);
-    }
-
-    /// Set the total number of edges
-    pub fn set_total_edges(&self, count: i64) {
-        self.total_edges.set(count);
-    }
-
-    /// Increment total edges count
-    pub fn inc_total_edges(&self) {
-        self.total_edges.inc();
-    }
-
-    /// Increment total edges by amount
-    pub fn inc_total_edges_by(&self, count: i64) {
-        self.total_edges.add(count);
-    }
-
-    /// Set cache size in bytes
-    pub fn set_cache_size_bytes(&self, size: i64) {
-        self.cache_size_bytes.set(size);
-    }
-
-    /// Set event buffer size
-    pub fn set_buffer_size(&self, size: i64) {
-        self.buffer_size.set(size);
-    }
-
-    // Production Metrics - gRPC Helper Methods
-
-    /// Record a gRPC request with method and status
-    pub fn record_grpc_request(&self, method: &str, status: &str) {
-        self.grpc_requests_total
-            .with_label_values(&[method, status])
-            .inc();
-    }
-
-    /// Record gRPC request duration for a method
-    pub fn record_grpc_request_duration(&self, method: &str, duration_secs: f64) {
-        self.grpc_request_duration
-            .with_label_values(&[method])
-            .observe(duration_secs);
-    }
-
-    /// Increment active gRPC streams count
-    pub fn inc_grpc_active_streams(&self) {
-        self.grpc_active_streams.inc();
-    }
-
-    /// Decrement active gRPC streams count
-    pub fn dec_grpc_active_streams(&self) {
-        self.grpc_active_streams.dec();
-    }
-
-    /// Set the number of active gRPC streams
-    pub fn set_grpc_active_streams(&self, count: i64) {
-        self.grpc_active_streams.set(count);
-    }
-
-    // Production Metrics - Plugin Helper Methods
-
-    /// Record a plugin execution
-    pub fn record_plugin_execution(&self, plugin: &str, hook: &str) {
-        self.plugin_executions_total
-            .with_label_values(&[plugin, hook])
-            .inc();
-    }
-
-    /// Record plugin execution duration
-    pub fn record_plugin_duration(&self, plugin: &str, hook: &str, duration_secs: f64) {
-        self.plugin_duration
-            .with_label_values(&[plugin, hook])
-            .observe(duration_secs);
-    }
-
-    /// Record a plugin error
-    pub fn record_plugin_error(&self, plugin: &str, error_type: &str) {
-        self.plugin_errors_total
-            .with_label_values(&[plugin, error_type])
-            .inc();
-    }
-
-    // Production Metrics - Integration Helper Methods
-
-    /// Record an LLM-Registry API call
-    pub fn record_registry_call(&self, operation: &str, status: &str) {
-        self.registry_calls_total
-            .with_label_values(&[operation, status])
-            .inc();
-    }
-
-    /// Record a successful vault archive operation
-    pub fn record_vault_archive(&self) {
-        self.vault_archives_total.inc();
-    }
-
-    /// Record multiple vault archive operations
-    pub fn record_vault_archives(&self, count: u64) {
-        self.vault_archives_total.inc_by(count);
-    }
-
-    /// Record a successful vault retrieval operation
-    pub fn record_vault_retrieval(&self) {
-        self.vault_retrievals_total.inc();
-    }
-
-    /// Record multiple vault retrieval operations
-    pub fn record_vault_retrievals(&self, count: u64) {
-        self.vault_retrievals_total.inc_by(count);
-    }
-
-    /// Record a vault error
-    pub fn record_vault_error(&self) {
-        self.vault_errors_total.inc();
-    }
-
-    /// Record multiple vault errors
-    pub fn record_vault_errors(&self, count: u64) {
-        self.vault_errors_total.inc_by(count);
-    }
-
-    /// Get a snapshot of all counter values
-    pub fn get_counter_snapshot(&self) -> MetricsCounterSnapshot {
-        MetricsCounterSnapshot {
-            nodes_created: self.nodes_created.get(),
-            edges_created: self.edges_created.get(),
-            prompts_submitted: self.prompts_submitted.get(),
-            responses_generated: self.responses_generated.get(),
-            tools_invoked: self.tools_invoked.get(),
-            agent_handoffs: self.agent_handoffs.get(),
-            template_instantiations: self.template_instantiations.get(),
-            queries_executed: self.queries_executed.get(),
-        }
-    }
-
-    /// Get a snapshot of all gauge values
-    pub fn get_gauge_snapshot(&self) -> MetricsGaugeSnapshot {
-        MetricsGaugeSnapshot {
-            active_sessions: self.active_sessions.get(),
-            total_nodes: self.total_nodes.get(),
-            total_edges: self.total_edges.get(),
-            cache_size_bytes: self.cache_size_bytes.get(),
-            buffer_size: self.buffer_size.get(),
-        }
-    }
-
-    /// Get a snapshot of gRPC metrics
-    pub fn get_grpc_snapshot(&self) -> GrpcMetricsSnapshot {
-        GrpcMetricsSnapshot {
-            active_streams: self.grpc_active_streams.get(),
-        }
-    }
-
-    /// Get a snapshot of vault metrics
-    pub fn get_vault_snapshot(&self) -> VaultMetricsSnapshot {
-        VaultMetricsSnapshot {
-            total_archives: self.vault_archives_total.get(),
-            total_retrievals: self.vault_retrievals_total.get(),
-            total_errors: self.vault_errors_total.get(),
-        }
-    }
-}
-
-/// Snapshot of counter metric values
-#[derive(Debug, Clone, PartialEq)]
-pub struct MetricsCounterSnapshot {
-    /// Total nodes created
-    pub nodes_created: u64,
-    /// Total edges created
-    pub edges_created: u64,
-    /// Total prompts submitted
-    pub prompts_submitted: u64,
-    /// Total responses generated
-    pub responses_generated: u64,
-    /// Total tools invoked
-    pub tools_invoked: u64,
-    /// Total agent handoffs
-    pub agent_handoffs: u64,
-    /// Total template instantiations
-    pub template_instantiations: u64,
-    /// Total queries executed
-    pub queries_executed: u64,
-}
-
-/// Snapshot of gauge metric values
-#[derive(Debug, Clone, PartialEq)]
-pub struct MetricsGaugeSnapshot {
-    /// Current active sessions
-    pub active_sessions: i64,
-    /// Total nodes in graph
-    pub total_nodes: i64,
-    /// Total edges in graph
-    pub total_edges: i64,
-    /// Cache size in bytes
-    pub cache_size_bytes: i64,
-    /// Event buffer size
-    pub buffer_size: i64,
-}
-
-/// Production metrics snapshot for gRPC operations
-#[derive(Debug, Clone, PartialEq)]
-pub struct GrpcMetricsSnapshot {
-    /// Number of active gRPC streams
-    pub active_streams: i64,
-}
-
-/// Production metrics snapshot for vault operations
-#[derive(Debug, Clone, PartialEq)]
-pub struct VaultMetricsSnapshot {
-    /// Total archives to vault
-    pub total_archives: u64,
-    /// Total retrievals from vault
-    pub total_retrievals: u64,
-    /// Total vault errors
-    pub total_errors: u64,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_metrics_creation() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Verify all metrics are initialized
-        assert_eq!(metrics.nodes_created.get(), 0);
-        assert_eq!(metrics.edges_created.get(), 0);
-        assert_eq!(metrics.active_sessions.get(), 0);
-    }
-
-    #[test]
-    fn test_counter_recording() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_node_created();
-        assert_eq!(metrics.nodes_created.get(), 1);
-
-        metrics.record_nodes_created(5);
-        assert_eq!(metrics.nodes_created.get(), 6);
-
-        metrics.record_edge_created();
-        assert_eq!(metrics.edges_created.get(), 1);
-    }
-
-    #[test]
-    fn test_all_counters() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_node_created();
-        metrics.record_edge_created();
-        metrics.record_prompt_submitted();
-        metrics.record_response_generated();
-        metrics.record_tool_invoked();
-        metrics.record_agent_handoff();
-        metrics.record_template_instantiation();
-        metrics.record_query_executed();
-
-        assert_eq!(metrics.nodes_created.get(), 1);
-        assert_eq!(metrics.edges_created.get(), 1);
-        assert_eq!(metrics.prompts_submitted.get(), 1);
-        assert_eq!(metrics.responses_generated.get(), 1);
-        assert_eq!(metrics.tools_invoked.get(), 1);
-        assert_eq!(metrics.agent_handoffs.get(), 1);
-        assert_eq!(metrics.template_instantiations.get(), 1);
-        assert_eq!(metrics.queries_executed.get(), 1);
-    }
-
-    #[test]
-    fn test_histogram_recording() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_write_latency(0.025);
-        metrics.record_read_latency(0.001);
-        metrics.record_query_duration(0.5);
-        metrics.record_tool_duration(2.0);
-        metrics.record_batch_size(50);
-
-        // Histograms don't expose simple get() - verify no panics
-        assert!(true);
-    }
-
-    #[test]
-    fn test_gauge_updates() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.set_active_sessions(5);
-        assert_eq!(metrics.active_sessions.get(), 5);
-
-        metrics.inc_active_sessions();
-        assert_eq!(metrics.active_sessions.get(), 6);
-
-        metrics.dec_active_sessions();
-        assert_eq!(metrics.active_sessions.get(), 5);
-
-        metrics.set_total_nodes(100);
-        assert_eq!(metrics.total_nodes.get(), 100);
-
-        metrics.inc_total_nodes();
-        assert_eq!(metrics.total_nodes.get(), 101);
-
-        metrics.inc_total_nodes_by(9);
-        assert_eq!(metrics.total_nodes.get(), 110);
-    }
-
-    #[test]
-    fn test_all_gauges() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.set_active_sessions(10);
-        metrics.set_total_nodes(500);
-        metrics.set_total_edges(800);
-        metrics.set_cache_size_bytes(1024 * 1024);
-        metrics.set_buffer_size(25);
-
-        assert_eq!(metrics.active_sessions.get(), 10);
-        assert_eq!(metrics.total_nodes.get(), 500);
-        assert_eq!(metrics.total_edges.get(), 800);
-        assert_eq!(metrics.cache_size_bytes.get(), 1024 * 1024);
-        assert_eq!(metrics.buffer_size.get(), 25);
-    }
-
-    #[test]
-    fn test_counter_snapshot() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_node_created();
-        metrics.record_edges_created(3);
-        metrics.record_prompt_submitted();
-
-        let snapshot = metrics.get_counter_snapshot();
-        assert_eq!(snapshot.nodes_created, 1);
-        assert_eq!(snapshot.edges_created, 3);
-        assert_eq!(snapshot.prompts_submitted, 1);
-        assert_eq!(snapshot.responses_generated, 0);
-    }
-
-    #[test]
-    fn test_gauge_snapshot() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.set_active_sessions(7);
-        metrics.set_total_nodes(150);
-        metrics.set_cache_size_bytes(2048);
-
-        let snapshot = metrics.get_gauge_snapshot();
-        assert_eq!(snapshot.active_sessions, 7);
-        assert_eq!(snapshot.total_nodes, 150);
-        assert_eq!(snapshot.cache_size_bytes, 2048);
-    }
-
-    #[test]
-    fn test_metrics_clone() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_node_created();
-
-        let cloned = metrics.clone();
-        cloned.record_node_created();
-
-        // Both should see the same counter
-        assert_eq!(metrics.nodes_created.get(), 2);
-        assert_eq!(cloned.nodes_created.get(), 2);
-    }
-
-    #[test]
-    fn test_concurrent_counter_updates() {
-        use std::sync::Arc;
-        use std::thread;
-
-        let registry = Registry::new();
-        let metrics = Arc::new(PrometheusMetrics::new(&registry).unwrap());
-
-        let mut handles = vec![];
-        for _ in 0..10 {
-            let metrics_clone = Arc::clone(&metrics);
-            let handle = thread::spawn(move || {
-                for _ in 0..100 {
-                    metrics_clone.record_node_created();
-                }
-            });
-            handles.push(handle);
-        }
-
-        for handle in handles {
-            handle.join().unwrap();
-        }
-
-        assert_eq!(metrics.nodes_created.get(), 1000);
-    }
-
-    #[test]
-    fn test_latency_buckets() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Test various latency ranges
-        metrics.record_write_latency(0.001); // 1ms
-        metrics.record_write_latency(0.010); // 10ms
-        metrics.record_write_latency(0.100); // 100ms
-        metrics.record_write_latency(1.000); // 1s
-
-        metrics.record_read_latency(0.0001); // 0.1ms
-        metrics.record_read_latency(0.001); // 1ms
-        metrics.record_read_latency(0.01); // 10ms
-    }
-
-    #[test]
-    fn test_batch_size_distribution() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_batch_size(1);
-        metrics.record_batch_size(10);
-        metrics.record_batch_size(50);
-        metrics.record_batch_size(100);
-        metrics.record_batch_size(500);
-    }
-
-    #[test]
-    fn test_edge_operations_tracking() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.set_total_edges(100);
-        metrics.record_edge_created();
-
-        // Track edge creation but gauge doesn't auto-increment
-        assert_eq!(metrics.edges_created.get(), 1);
-
-        // Manually sync gauge with counter
-        metrics.inc_total_edges();
-        assert_eq!(metrics.total_edges.get(), 101);
-    }
-
-    #[test]
-    fn test_session_lifecycle() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Session created
-        metrics.inc_active_sessions();
-        assert_eq!(metrics.active_sessions.get(), 1);
-
-        // More sessions created
-        metrics.inc_active_sessions();
-        metrics.inc_active_sessions();
-        assert_eq!(metrics.active_sessions.get(), 3);
-
-        // Session ended
-        metrics.dec_active_sessions();
-        assert_eq!(metrics.active_sessions.get(), 2);
-    }
-
-    #[test]
-    fn test_prometheus_text_export() {
-        use prometheus::TextEncoder;
-
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_node_created();
-        metrics.record_prompt_submitted();
-        metrics.set_active_sessions(5);
-
-        let encoder = TextEncoder::new();
-        let metric_families = registry.gather();
-        let encoded = encoder.encode_to_string(&metric_families).unwrap();
-
-        assert!(encoded.contains("memory_graph_nodes_created_total"));
-        assert!(encoded.contains("memory_graph_prompts_submitted_total"));
-        assert!(encoded.contains("memory_graph_active_sessions"));
-    }
-
-    // Production Metrics Tests - gRPC
-
-    #[test]
-    fn test_grpc_request_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record various gRPC requests
-        metrics.record_grpc_request("CreateSession", "success");
-        metrics.record_grpc_request("CreateSession", "success");
-        metrics.record_grpc_request("GetNode", "success");
-        metrics.record_grpc_request("UpdateNode", "error");
-
-        // Verify counters are tracked per label
-        let grpc_total = metrics
-            .grpc_requests_total
-            .with_label_values(&["CreateSession", "success"])
-            .get();
-        assert_eq!(grpc_total, 2);
-
-        let error_total = metrics
-            .grpc_requests_total
-            .with_label_values(&["UpdateNode", "error"])
-            .get();
-        assert_eq!(error_total, 1);
-    }
-
-    #[test]
-    fn test_grpc_request_duration() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record request durations
-        metrics.record_grpc_request_duration("CreateSession", 0.015);
-        metrics.record_grpc_request_duration("Query", 0.125);
-        metrics.record_grpc_request_duration("BatchCreateNodes", 0.45);
-
-        // Verify no panics - histogram values aren't directly accessible
-        assert!(true);
-    }
-
-    #[test]
-    fn test_grpc_active_streams() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        assert_eq!(metrics.grpc_active_streams.get(), 0);
-
-        metrics.inc_grpc_active_streams();
-        assert_eq!(metrics.grpc_active_streams.get(), 1);
-
-        metrics.inc_grpc_active_streams();
-        metrics.inc_grpc_active_streams();
-        assert_eq!(metrics.grpc_active_streams.get(), 3);
-
-        metrics.dec_grpc_active_streams();
-        assert_eq!(metrics.grpc_active_streams.get(), 2);
-
-        metrics.set_grpc_active_streams(10);
-        assert_eq!(metrics.grpc_active_streams.get(), 10);
-    }
-
-    #[test]
-    fn test_grpc_snapshot() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.set_grpc_active_streams(5);
-
-        let snapshot = metrics.get_grpc_snapshot();
-        assert_eq!(snapshot.active_streams, 5);
-    }
-
-    // Production Metrics Tests - Plugin System
-
-    #[test]
-    fn test_plugin_execution_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record plugin executions
-        metrics.record_plugin_execution("audit_logger", "on_node_create");
-        metrics.record_plugin_execution("audit_logger", "on_node_create");
-        metrics.record_plugin_execution("validator", "on_edge_create");
-        metrics.record_plugin_execution("audit_logger", "on_session_close");
-
-        // Verify counters
-        let audit_create = metrics
-            .plugin_executions_total
-            .with_label_values(&["audit_logger", "on_node_create"])
-            .get();
-        assert_eq!(audit_create, 2);
-
-        let validator_edge = metrics
-            .plugin_executions_total
-            .with_label_values(&["validator", "on_edge_create"])
-            .get();
-        assert_eq!(validator_edge, 1);
-    }
-
-    #[test]
-    fn test_plugin_duration_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record plugin durations
-        metrics.record_plugin_duration("audit_logger", "on_node_create", 0.002);
-        metrics.record_plugin_duration("validator", "on_edge_create", 0.015);
-        metrics.record_plugin_duration("transformer", "on_query", 0.125);
-
-        // Verify no panics
-        assert!(true);
-    }
-
-    #[test]
-    fn test_plugin_error_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record plugin errors
-        metrics.record_plugin_error("validator", "validation_failed");
-        metrics.record_plugin_error("validator", "validation_failed");
-        metrics.record_plugin_error("transformer", "timeout");
-        metrics.record_plugin_error("audit_logger", "connection_error");
-
-        // Verify error counters
-        let validation_errors = metrics
-            .plugin_errors_total
-            .with_label_values(&["validator", "validation_failed"])
-            .get();
-        assert_eq!(validation_errors, 2);
-
-        let timeout_errors = metrics
-            .plugin_errors_total
-            .with_label_values(&["transformer", "timeout"])
-            .get();
-        assert_eq!(timeout_errors, 1);
-    }
-
-    // Production Metrics Tests - Integrations
-
-    #[test]
-    fn test_registry_call_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record registry API calls
-        metrics.record_registry_call("register_model", "success");
-        metrics.record_registry_call("register_model", "success");
-        metrics.record_registry_call("get_metadata", "success");
-        metrics.record_registry_call("update_version", "error");
-
-        // Verify counters
-        let register_success = metrics
-            .registry_calls_total
-            .with_label_values(&["register_model", "success"])
-            .get();
-        assert_eq!(register_success, 2);
-
-        let update_error = metrics
-            .registry_calls_total
-            .with_label_values(&["update_version", "error"])
-            .get();
-        assert_eq!(update_error, 1);
-    }
-
-    #[test]
-    fn test_vault_archive_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        assert_eq!(metrics.vault_archives_total.get(), 0);
-
-        metrics.record_vault_archive();
-        assert_eq!(metrics.vault_archives_total.get(), 1);
-
-        metrics.record_vault_archives(5);
-        assert_eq!(metrics.vault_archives_total.get(), 6);
-    }
-
-    #[test]
-    fn test_vault_retrieval_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        assert_eq!(metrics.vault_retrievals_total.get(), 0);
-
-        metrics.record_vault_retrieval();
-        assert_eq!(metrics.vault_retrievals_total.get(), 1);
-
-        metrics.record_vault_retrievals(3);
-        assert_eq!(metrics.vault_retrievals_total.get(), 4);
-    }
-
-    #[test]
-    fn test_vault_error_metrics() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        assert_eq!(metrics.vault_errors_total.get(), 0);
-
-        metrics.record_vault_error();
-        assert_eq!(metrics.vault_errors_total.get(), 1);
-
-        metrics.record_vault_errors(2);
-        assert_eq!(metrics.vault_errors_total.get(), 3);
-    }
-
-    #[test]
-    fn test_vault_snapshot() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        metrics.record_vault_archives(10);
-        metrics.record_vault_retrievals(5);
-        metrics.record_vault_errors(2);
-
-        let snapshot = metrics.get_vault_snapshot();
-        assert_eq!(snapshot.total_archives, 10);
-        assert_eq!(snapshot.total_retrievals, 5);
-        assert_eq!(snapshot.total_errors, 2);
-    }
-
-    #[test]
-    fn test_production_metrics_text_export() {
-        use prometheus::TextEncoder;
-
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Record production metrics
-        metrics.record_grpc_request("CreateSession", "success");
-        metrics.record_plugin_execution("audit_logger", "on_node_create");
-        metrics.record_registry_call("register_model", "success");
-        metrics.record_vault_archive();
-
-        let encoder = TextEncoder::new();
-        let metric_families = registry.gather();
-        let encoded = encoder.encode_to_string(&metric_families).unwrap();
-
-        // Verify production metrics are exported
-        assert!(encoded.contains("memory_graph_grpc_requests_total"));
-        assert!(encoded.contains("memory_graph_plugin_executions_total"));
-        assert!(encoded.contains("memory_graph_registry_calls_total"));
-        assert!(encoded.contains("memory_graph_vault_archives_total"));
-    }
-
-    #[test]
-    fn test_complete_production_workflow() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Simulate a complete gRPC request with plugin execution
-        metrics.inc_grpc_active_streams();
-        metrics.record_grpc_request("CreateNode", "success");
-        metrics.record_grpc_request_duration("CreateNode", 0.025);
-
-        // Plugin hooks execute
-        metrics.record_plugin_execution("validator", "on_node_create");
-        metrics.record_plugin_duration("validator", "on_node_create", 0.003);
-        metrics.record_plugin_execution("audit_logger", "on_node_create");
-        metrics.record_plugin_duration("audit_logger", "on_node_create", 0.001);
-
-        // Registry integration
-        metrics.record_registry_call("track_operation", "success");
-
-        // Core metrics
-        metrics.record_node_created();
-        metrics.inc_total_nodes();
-
-        // Stream completes
-        metrics.dec_grpc_active_streams();
-
-        // Verify final state
-        assert_eq!(metrics.grpc_active_streams.get(), 0);
-        assert_eq!(metrics.nodes_created.get(), 1);
-        assert_eq!(metrics.total_nodes.get(), 1);
-    }
-
-    #[test]
-    fn test_all_production_metrics_initialized() {
-        let registry = Registry::new();
-        let metrics = PrometheusMetrics::new(&registry).unwrap();
-
-        // Verify all production metrics are initialized
-        assert_eq!(metrics.grpc_active_streams.get(), 0);
-        assert_eq!(metrics.vault_archives_total.get(), 0);
-        assert_eq!(metrics.vault_retrievals_total.get(), 0);
-        assert_eq!(metrics.vault_errors_total.get(), 0);
-    }
-}