use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub enum TraceEvent {
ConnectTcp {
phase: TracePhase,
host: String,
port: u16,
},
ConnectUnixSocket {
phase: TracePhase,
path: String,
},
StartTls {
phase: TracePhase,
server_hostname: String,
},
Retry {
phase: TracePhase,
delay_ms: u64,
},
Close {
phase: TracePhase,
},
SendRequestHeaders {
phase: TracePhase,
method: String,
target: String,
},
SendRequestBody {
phase: TracePhase,
},
ReceiveResponseHeaders {
phase: TracePhase,
status: u16,
},
ReceiveResponseBody {
phase: TracePhase,
},
ResponseClosed {
phase: TracePhase,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TracePhase {
Started,
Complete,
Failed,
}
impl fmt::Display for TracePhase {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Started => write!(f, "started"),
Self::Complete => write!(f, "complete"),
Self::Failed => write!(f, "failed"),
}
}
}
#[must_use]
pub fn event_to_httpcore_name(event: &TraceEvent) -> (&'static str, String) {
match event {
TraceEvent::ConnectTcp { phase, .. } => ("connection", format!("connect_tcp.{phase}")),
TraceEvent::ConnectUnixSocket { phase, .. } => {
("connection", format!("connect_unix_socket.{phase}"))
}
TraceEvent::StartTls { phase, .. } => ("connection", format!("start_tls.{phase}")),
TraceEvent::Retry { phase, .. } => ("connection", format!("retry.{phase}")),
TraceEvent::Close { phase } => ("connection", format!("close.{phase}")),
TraceEvent::SendRequestHeaders { phase, .. } => {
("http11", format!("send_request_headers.{phase}"))
}
TraceEvent::SendRequestBody { phase } => ("http11", format!("send_request_body.{phase}")),
TraceEvent::ReceiveResponseHeaders { phase, .. } => {
("http11", format!("receive_response_headers.{phase}"))
}
TraceEvent::ReceiveResponseBody { phase } => {
("http11", format!("receive_response_body.{phase}"))
}
TraceEvent::ResponseClosed { phase } => ("http11", format!("response_closed.{phase}")),
}
}
pub fn event_to_info(event: &TraceEvent) -> HashMap<String, EventValue> {
let mut info = HashMap::new();
match event {
TraceEvent::ConnectTcp { host, port, .. } => {
info.insert("host".into(), EventValue::String(host.clone()));
info.insert("port".into(), EventValue::U16(*port));
}
TraceEvent::ConnectUnixSocket { path, .. } => {
info.insert("path".into(), EventValue::String(path.clone()));
}
TraceEvent::StartTls {
server_hostname, ..
} => {
info.insert(
"server_hostname".into(),
EventValue::String(server_hostname.clone()),
);
}
TraceEvent::Retry { delay_ms, .. } => {
info.insert("delay_ms".into(), EventValue::U64(*delay_ms));
}
TraceEvent::SendRequestHeaders { method, target, .. } => {
info.insert("method".into(), EventValue::String(method.clone()));
info.insert("target".into(), EventValue::String(target.clone()));
}
TraceEvent::ReceiveResponseHeaders { status, .. } => {
info.insert("status".into(), EventValue::U16(*status));
}
_ => {}
}
info
}
#[derive(Debug, Clone, PartialEq)]
pub enum EventValue {
String(String),
U16(u16),
U64(u64),
}
pub trait TraceObserver: Send + Sync + fmt::Debug {
fn on_event(&self, event: &TraceEvent) -> OnEventAction;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OnEventAction {
Continue,
Abort,
}
#[derive(Debug)]
pub struct NoopTraceObserver;
impl TraceObserver for NoopTraceObserver {
fn on_event(&self, _event: &TraceEvent) -> OnEventAction {
OnEventAction::Continue
}
}
#[derive(Debug, Clone)]
pub struct CollectingTraceObserver {
events: Arc<std::sync::Mutex<Vec<TraceEvent>>>,
}
impl Default for CollectingTraceObserver {
fn default() -> Self {
Self::new()
}
}
impl CollectingTraceObserver {
#[must_use]
pub fn new() -> Self {
Self {
events: Arc::new(std::sync::Mutex::new(Vec::new())),
}
}
pub fn drain(&self) -> Vec<TraceEvent> {
std::mem::take(
&mut *self
.events
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner),
)
}
#[must_use]
pub fn len(&self) -> usize {
self.events
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
impl TraceObserver for CollectingTraceObserver {
fn on_event(&self, event: &TraceEvent) -> OnEventAction {
self.events
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.push(event.clone());
OnEventAction::Continue
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn event_to_httpcore_name_connect_tcp() {
let event = TraceEvent::ConnectTcp {
phase: TracePhase::Started,
host: "example.com".into(),
port: 443,
};
let (prefix, name) = event_to_httpcore_name(&event);
assert_eq!(prefix, "connection");
assert_eq!(name, "connect_tcp.started");
}
#[test]
fn event_to_httpcore_name_send_headers() {
let event = TraceEvent::SendRequestHeaders {
phase: TracePhase::Complete,
method: "GET".into(),
target: "/".into(),
};
let (prefix, name) = event_to_httpcore_name(&event);
assert_eq!(prefix, "http11");
assert_eq!(name, "send_request_headers.complete");
}
#[test]
fn event_to_info_connect_tcp() {
let event = TraceEvent::ConnectTcp {
phase: TracePhase::Started,
host: "example.com".into(),
port: 443,
};
let info = event_to_info(&event);
assert_eq!(
info.get("host"),
Some(&EventValue::String("example.com".into()))
);
assert_eq!(info.get("port"), Some(&EventValue::U16(443)));
}
#[test]
fn collecting_observer_stores_events() {
let observer = CollectingTraceObserver::new();
let action = observer.on_event(&TraceEvent::Close {
phase: TracePhase::Started,
});
assert_eq!(action, OnEventAction::Continue);
observer.on_event(&TraceEvent::Close {
phase: TracePhase::Complete,
});
assert_eq!(observer.len(), 2);
let events = observer.drain();
assert_eq!(events.len(), 2);
assert!(observer.is_empty());
}
}