mockforge-observability 0.3.108

Observability features for MockForge including Prometheus metrics, OpenTelemetry tracing, and recording
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! MockForge Observability
//!
//! Provides comprehensive observability features including:
//! - Structured logging with JSON support
//! - Prometheus metrics export
//! - OpenTelemetry distributed tracing
//! - Request/response recording (flight recorder)
//! - Scenario control and chaos engineering
//! - System metrics collection (CPU, memory, threads)
//!
//! # Example
//!
//! ```rust
//! use mockforge_observability::prometheus::MetricsRegistry;
//!
//! let registry = MetricsRegistry::new();
//! registry.record_http_request("GET", 200, 0.045);
//! ```

pub mod logging;
pub mod prometheus;
pub mod system_metrics;
pub mod tracing_integration;

// Re-export commonly used items
pub use logging::{init_logging, init_logging_with_otel, LoggingConfig};
pub use prometheus::{get_global_registry, MetricsRegistry};
pub use system_metrics::{start_system_metrics_collector, SystemMetricsConfig};
pub use tracing_integration::{init_with_otel, shutdown_otel, OtelTracingConfig};

/// Protocol types for metrics tracking
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Protocol {
    Http,
    Grpc,
    WebSocket,
    GraphQL,
}

impl Protocol {
    pub fn as_str(&self) -> &'static str {
        match self {
            Protocol::Http => "http",
            Protocol::Grpc => "grpc",
            Protocol::WebSocket => "websocket",
            Protocol::GraphQL => "graphql",
        }
    }
}

impl std::fmt::Display for Protocol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashSet;

    #[test]
    fn test_protocol_display() {
        assert_eq!(Protocol::Http.to_string(), "http");
        assert_eq!(Protocol::Grpc.to_string(), "grpc");
        assert_eq!(Protocol::WebSocket.to_string(), "websocket");
        assert_eq!(Protocol::GraphQL.to_string(), "graphql");
    }

    #[test]
    fn test_protocol_as_str() {
        assert_eq!(Protocol::Http.as_str(), "http");
        assert_eq!(Protocol::Grpc.as_str(), "grpc");
        assert_eq!(Protocol::WebSocket.as_str(), "websocket");
        assert_eq!(Protocol::GraphQL.as_str(), "graphql");
    }

    #[test]
    fn test_protocol_debug() {
        assert_eq!(format!("{:?}", Protocol::Http), "Http");
        assert_eq!(format!("{:?}", Protocol::Grpc), "Grpc");
        assert_eq!(format!("{:?}", Protocol::WebSocket), "WebSocket");
        assert_eq!(format!("{:?}", Protocol::GraphQL), "GraphQL");
    }

    #[test]
    fn test_protocol_clone() {
        let proto = Protocol::Http;
        let cloned = Clone::clone(&proto);
        assert_eq!(proto, cloned);
    }

    #[test]
    fn test_protocol_copy() {
        let proto = Protocol::Grpc;
        let copied = proto;
        assert_eq!(Protocol::Grpc, copied);
        assert_eq!(proto, Protocol::Grpc); // proto still accessible
    }

    #[test]
    fn test_protocol_eq() {
        assert_eq!(Protocol::Http, Protocol::Http);
        assert_eq!(Protocol::Grpc, Protocol::Grpc);
        assert_ne!(Protocol::Http, Protocol::Grpc);
        assert_ne!(Protocol::WebSocket, Protocol::GraphQL);
    }

    #[test]
    fn test_protocol_hash() {
        let mut set = HashSet::new();
        set.insert(Protocol::Http);
        set.insert(Protocol::Grpc);
        set.insert(Protocol::WebSocket);
        set.insert(Protocol::GraphQL);

        assert_eq!(set.len(), 4);
        assert!(set.contains(&Protocol::Http));
        assert!(set.contains(&Protocol::Grpc));
        assert!(set.contains(&Protocol::WebSocket));
        assert!(set.contains(&Protocol::GraphQL));

        // Duplicate insertion shouldn't increase size
        set.insert(Protocol::Http);
        assert_eq!(set.len(), 4);
    }

    #[test]
    fn test_protocol_all_variants() {
        let protocols = [
            Protocol::Http,
            Protocol::Grpc,
            Protocol::WebSocket,
            Protocol::GraphQL,
        ];

        for proto in protocols {
            let str_repr = proto.as_str();
            assert!(!str_repr.is_empty());
            assert_eq!(proto.to_string(), str_repr);
        }
    }
}