Struct SessionMetrics 

pub struct SessionMetrics {

    pub start: Option<Instant>,
    pub start_wall: Option<SystemTime>,
    pub service_time: Duration,
    pub wait_time: Duration,
    pub bin: usize,
    pub bout: usize,
    pub service_start: Option<Instant>,
    pub wait_start: Instant,
    pub backend_id: Option<Rc<str>>,
    pub backend_start: Option<Instant>,
    pub backend_connected: Option<Instant>,
    pub backend_headers_received: Option<Instant>,
    pub backend_stop: Option<Instant>,
    pub backend_bin: usize,
    pub backend_bout: usize,
}

Fields

start: Option<Instant>

date at which we started handling that request

start_wall: Option<SystemTime>

wall-clock timestamp captured alongside start, for access-log consumers that need an absolute start time (e.g. OTel span reconstruction) without subtracting a monotonic duration from a wall-clock end time — which mixes two unsynchronised clock sources.

service_time: Duration

time actually spent handling the request

wait_time: Duration

time spent waiting for its turn

bin: usize

bytes received by the frontend

bout: usize

bytes sent by the frontend

service_start: Option<Instant>

date at which we started working on the request

wait_start: Instant

backend_id: Option<Rc<str>>

The id of the backend serving this request. An Rc<str> so the mux shares the one its BackendId carries instead of copying it (#1579).

backend_start: Option<Instant>

backend_connected: Option<Instant>

backend_headers_received: Option<Instant>

date at which the backend’s response headers finished parsing — the time-to-first-header-byte anchor nginx calls $upstream_header_time. Set by the L7 read paths only; raw TCP has no headers and leaves it None (see SessionMetrics::backend_header_time).

backend_stop: Option<Instant>

backend_bin: usize

backend_bout: usize

Implementations

impl SessionMetrics

pub fn new(wait_time: Option<Duration>) -> SessionMetrics

pub fn reset(&mut self)

pub fn service_start(&mut self)

pub fn service_stop(&mut self)

pub fn wait_start(&mut self)

pub fn service_time(&self) -> Duration

pub fn mark_request_start(&mut self) -> Instant

Arm both the monotonic and wall-clock start timestamps together. This must be the single place that sets start + start_wall outside of new(), so the two fields can never desynchronize. Returns the monotonic instant so callers that need it (e.g. service_start) can reuse it without a second syscall.

pub fn request_time(&self) -> Duration

time elapsed since the beginning of the session

pub fn start_wall_ns(&self) -> Option<i128>

Wall-clock start time as nanoseconds since the Unix epoch, or None if the monotonic start has not been set yet (post-reset(), pre-service_start()).

pub fn backend_start(&mut self)

pub fn backend_connected(&mut self)

pub fn backend_headers_received(&mut self)

The backend’s response headers have just finished parsing. Called from the L7 read paths at the header -> body transition, once per response.

Overwrites, exactly like Self::backend_stop and for the same reason: a 1xx informational response is forwarded and the back buffer is then cleared — ConnectionH1::writable (lib/src/protocol/mux/h1.rs) in its 100-Continue and other-interim (102-199) arms, ConnectionH2::handle_1xx_reset (lib/src/protocol/mux/h2.rs) — so the final response re-enters that transition from the initial parsing phase. Last write wins, which anchors this on the FINAL response headers — the same response backend_stop anchors on, and what nginx reports in $upstream_header_time. A set-once guard would anchor the pair on two different responses and floor the metric at ~0ms for every Expect: 100-continue client, hiding the upstream think time the metric exists to expose.

pub fn backend_stop(&mut self)

pub fn backend_response_time(&self) -> Option<Duration>

pub fn backend_connection_time(&self) -> Option<Duration>

pub fn backend_header_time(&self) -> Option<Duration>

Time from the established backend connection to the moment its response headers finished parsing — nginx’s $upstream_header_time, the third of the three upstream timings of sozu-proxy/sozu#426.

Deliberately WITHOUT the elapsed-so-far fallback that Self::backend_response_time carries for its backend_stop-is-None case. That fallback serves a live read of a response still streaming; a time-to-first-header-byte has no in-flight meaning, because no header byte has arrived. Returning Instant::now() - connected anyway would publish a value that grows with the wait and then freezes wherever the session ended — indistinguishable, on a dashboard, from a slow backend that did answer. None is the honest answer, and it is also what keeps raw TCP (lib/src/tcp.rs, no headers at all) recording nothing here instead of recording a zero.

pub fn register_end_of_session(&self, context: &LogContext<'_>)

Trait Implementations

impl Clone for SessionMetrics

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SessionMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.