rift-http-proxy 0.4.0

Rift: high-performance HTTP chaos engineering proxy with Lua/Rhai/JavaScript scripting for fault injection.
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

//! Proxy recording for Mountebank-compatible record/replay functionality.
//!
//! Supports three modes:
//! - `proxyOnce`: Record first response, replay on subsequent matches
//! - `proxyAlways`: Always proxy, record all responses
//! - `proxyTransparent`: Always proxy, never record (default Rift behavior)
//!
//! Features:
//! - `addWaitBehavior`: Capture actual latency in recorded responses
//! - `predicateGenerators`: Auto-generate stubs from recorded requests
//! - File-based persistence for recordings
//!
//! # Module Structure
//!
//! - `mode` - Proxy recording mode enum
//! - `types` - Response and signature types
//! - `store` - Recording store implementation
//! - `stub_generator` - Mountebank stub generation

mod mode;
mod store;
mod stub_generator;
mod types;

// Re-export main types
pub use mode::ProxyMode;
pub use store::RecordingStore;
#[allow(unused_imports)]
pub use stub_generator::generate_stub;
pub use types::{RecordedResponse, RequestSignature};

use std::time::Instant;

/// Record a response with timing
// Public API for future use (higher-level recording helper)
pub fn record_with_timing<F, T>(store: &RecordingStore, signature: RequestSignature, f: F) -> T
where
    F: FnOnce() -> (T, u16, Vec<(String, String)>, Vec<u8>),
{
    let start = Instant::now();
    let (result, status, headers, body) = f();
    let latency_ms = start.elapsed().as_millis() as u64;

    let response = RecordedResponse {
        status,
        headers,
        body,
        latency_ms: Some(latency_ms),
        timestamp_secs: crate::util::unix_timestamp(),
    };

    store.record(signature, response);
    result
}