oxur-cli 0.2.1

CLI infrastructure and unified command-line tool for Oxur
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

//! Client-side metrics for REPL operations
//!
//! Provides [`MetricsClientAdapter`] wrapper that adds metrics collection
//! around any [`ReplClientAdapter`] implementation.

#[cfg(feature = "binary")]
use crate::repl::runner::ReplClientAdapter;
#[cfg(feature = "binary")]
use anyhow::Result;
#[cfg(feature = "binary")]
use async_trait::async_trait;
#[cfg(feature = "binary")]
use metrics::{counter, histogram};
#[cfg(feature = "binary")]
use oxur_repl::protocol::{OperationResult, Request, Response};
#[cfg(feature = "binary")]
use std::time::Instant;

/// Wrapper that adds metrics collection to any [`ReplClientAdapter`].
///
/// Records:
/// - `repl.client.requests_total` - Requests sent (labeled by operation)
/// - `repl.client.responses_total` - Responses received (labeled by status)
/// - `repl.client.response_latency_ms` - Round-trip latency histogram
///
/// # Example
///
/// ```no_run
/// use oxur_cli::repl::metrics::MetricsClientAdapter;
///
/// // Wrap an existing adapter
/// // let inner_adapter = TcpAdapter::new(...);
/// // let metrics_adapter = MetricsClientAdapter::new(inner_adapter);
/// // runner.run(&mut metrics_adapter).await?;
/// ```
#[cfg(feature = "binary")]
#[derive(Debug)]
#[allow(dead_code)] // Optional infrastructure - not yet wired into connect.rs
pub struct MetricsClientAdapter<C: ReplClientAdapter> {
    inner: C,
    request_start: Option<Instant>,
}

#[cfg(feature = "binary")]
#[allow(dead_code)] // Optional infrastructure - not yet wired into connect.rs
impl<C: ReplClientAdapter> MetricsClientAdapter<C> {
    /// Create a new metrics-enabled adapter wrapping an inner adapter.
    pub fn new(inner: C) -> Self {
        Self { inner, request_start: None }
    }

    /// Unwrap and return the inner adapter.
    pub fn into_inner(self) -> C {
        self.inner
    }
}

#[cfg(feature = "binary")]
#[async_trait]
impl<C: ReplClientAdapter> ReplClientAdapter for MetricsClientAdapter<C> {
    async fn send_eval(&mut self, request: Request) -> Result<()> {
        // Record request start time
        self.request_start = Some(Instant::now());

        // Extract operation name for metrics label
        let operation = match &request.operation {
            oxur_repl::protocol::Operation::CreateSession { .. } => "create_session",
            oxur_repl::protocol::Operation::Clone { .. } => "clone",
            oxur_repl::protocol::Operation::Eval { .. } => "eval",
            oxur_repl::protocol::Operation::Close => "close",
            oxur_repl::protocol::Operation::LsSessions => "ls_sessions",
            oxur_repl::protocol::Operation::LoadFile { .. } => "load_file",
            oxur_repl::protocol::Operation::Interrupt => "interrupt",
            oxur_repl::protocol::Operation::Describe { .. } => "describe",
            oxur_repl::protocol::Operation::History { .. } => "history",
            oxur_repl::protocol::Operation::ClearOutput => "clear_output",
            _ => "unknown",
        };

        counter!("repl.client.requests_total", "operation" => operation).increment(1);

        // Delegate to inner adapter
        self.inner.send_eval(request).await
    }

    async fn recv_response(&mut self) -> Result<Response> {
        let response = self.inner.recv_response().await?;

        // Record latency if we have a start time
        if let Some(start) = self.request_start.take() {
            let latency_ms = start.elapsed().as_millis() as f64;
            histogram!("repl.client.response_latency_ms").record(latency_ms);
        }

        // Record response status
        let status = match &response.result {
            OperationResult::Success { .. } => "success",
            OperationResult::Error { .. } => "error",
            OperationResult::Sessions { .. } => "success",
            OperationResult::HistoryEntries { .. } => "success",
            _ => "unknown",
        };
        counter!("repl.client.responses_total", "status" => status).increment(1);

        Ok(response)
    }

    async fn close(&mut self) -> Result<()> {
        self.inner.close().await
    }

    fn current_session(&self) -> &oxur_repl::protocol::SessionId {
        self.inner.current_session()
    }

    async fn handle_special_command(&mut self, input: &str, color_enabled: bool) -> Option<String> {
        self.inner.handle_special_command(input, color_enabled).await
    }
}

#[cfg(test)]
#[cfg(feature = "binary")]
mod tests {
    // Unit tests would require mocking ReplClientAdapter
    // Integration tests are more appropriate for this wrapper
}