← Observability Middleware (RED metrics) networkingmedium ready

Problem

Observability Middleware (RED metrics) (Rust)

Topics: middleware, atomics, RED metrics, Service/Layer

Problem

Build a middleware that records the RED signals for every request — Rate, Errors, Duration — plus a live in-flight gauge. The middleware wraps a Service (the same hand-written synchronous shape as the other HTTP challenges).

pub struct Metrics { /* … */ }
impl Metrics {
    pub fn new() -> Self;
    pub fn middleware<S: Service>(&self, next: S) -> MetricsService<S>;
    pub fn snapshot(&self) -> Snapshot;
}
pub struct Stat { pub count: i64, pub avg: Duration }
pub struct Snapshot { pub in_flight: i64, pub stats: HashMap<String, Stat> }

For each request the wrapped service must:

increment an in-flight gauge on entry, decrement on exit (even on an early return/panic);
time the inner call;
record count + total duration keyed by "{method} {path} {status}" (e.g. "GET /users 200").

snapshot() returns a consistent copy: per-key count and average latency, plus the current in-flight count.

Key concepts

Atomic gauge: the in-flight count is incremented/decremented concurrently — an AtomicI64 avoids a lock on the hot path. A Drop guard makes the decrement panic-safe.
Mutex map: the per-key (count, total_ns) map needs a Mutex; snapshot derives each average as total_ns / count.
Status from the response: unlike Go's ResponseWriter wrapping, the Response already carries its status, so the key is built directly from it.
RED method: Rate (count), Errors (count of 5xx keys), Duration (avg/percentiles) — the standard request-level signals for a service.

Grading

Your solution.rs is compiled together with a trusted tests.rs (which include!s it) using rustc --test. Only solution.rs is yours to edit.

Sign in to submit your solution.

Leaderboard score: lower is better, 1.0 ≈ reference

#	Name	score	ns/op	allocs

Output

No submission yet.

use std::collections::HashMap;
use std::sync::atomic::{AtomicI64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

/// A request flowing through the middleware stack.
#[derive(Clone, Default)]
pub struct Request {
    pub method: String,
    pub path: String,
}

impl Request {
    pub fn new(method: &str, path: &str) -> Self {
        Request {
            method: method.to_string(),
            path: path.to_string(),
        }
    }
}

/// A response carrying its HTTP-style status code.
pub struct Response {
    pub status: u16,
}

impl Response {
    pub fn new(status: u16) -> Self {
        Response { status }
    }
}

/// Turns a `Request` into a `Response` — the synchronous analog of tower's `Service`.
pub trait Service {
    fn call(&self, req: Request) -> Response;
}

/// Adapts a closure into a leaf `Service`.
pub struct HandlerFn<F>(pub F);

impl<F: Fn(Request) -> Response> Service for HandlerFn<F> {
    fn call(&self, req: Request) -> Response {
        (self.0)(req)
    }
}

/// One key's recorded request count and average latency.
#[derive(Debug, Clone, PartialEq)]
pub struct Stat {
    pub count: i64,
    pub avg: Duration,
}

/// A consistent point-in-time view of the metrics.
#[derive(Debug, Clone)]
pub struct Snapshot {
    pub in_flight: i64,
    pub stats: HashMap<String, Stat>,
}

#[allow(dead_code)]
struct Inner {
    in_flight: AtomicI64,
    // key -> (count, total nanoseconds)
    data: Mutex<HashMap<String, (i64, u128)>>,
}

/// Records RED metrics (Rate, Errors, Duration) plus a live in-flight gauge.
pub struct Metrics {
    inner: Arc<Inner>,
}

impl Metrics {
    pub fn new() -> Self {
        Metrics {
            inner: Arc::new(Inner {
                in_flight: AtomicI64::new(0),
                data: Mutex::new(HashMap::new()),
            }),
        }
    }

/// Wraps `next` so each request bumps the in-flight gauge, times the call, and
    /// records count + duration keyed by `"{method} {path} {status}"`.
    pub fn middleware<S: Service>(&self, next: S) -> MetricsService<S> {
        MetricsService {
            inner: Arc::clone(&self.inner),
            next,
        }
    }

/// Returns a consistent snapshot: per-key count + average latency, plus the
    /// current in-flight count.
    pub fn snapshot(&self) -> Snapshot {
        let _ = (&self.inner, Instant::now, Ordering::SeqCst);
        unimplemented!()
    }
}

pub struct MetricsService<S> {
    inner: Arc<Inner>,
    next: S,
}

impl<S: Service> Service for MetricsService<S> {
    fn call(&self, req: Request) -> Response {
        let _ = (&self.inner, &self.next, req);
        unimplemented!()
    }
}