|
|
use std::{ |
|
|
net::{SocketAddr, SocketAddrV4, TcpListener, TcpStream}, |
|
|
sync::{Arc, Mutex}, |
|
|
thread::spawn, |
|
|
}; |
|
|
|
|
|
use anyhow::{Result, bail}; |
|
|
use serde::{Deserialize, Serialize}; |
|
|
use tungstenite::{Message, accept}; |
|
|
|
|
|
use crate::{ |
|
|
store::SpanId, |
|
|
store_container::StoreContainer, |
|
|
timestamp::Timestamp, |
|
|
u64_string, |
|
|
viewer::{Update, ViewLineUpdate, ViewMode, Viewer}, |
|
|
}; |
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug)] |
|
|
#[serde(tag = "type")] |
|
|
#[serde(rename_all = "kebab-case")] |
|
|
pub enum ServerToClientMessage { |
|
|
ViewLine { |
|
|
#[serde(flatten)] |
|
|
update: ViewLineUpdate, |
|
|
}, |
|
|
ViewLinesCount { |
|
|
count: usize, |
|
|
max: u64, |
|
|
}, |
|
|
#[serde(rename_all = "camelCase")] |
|
|
QueryResult { |
|
|
#[serde(with = "u64_string")] |
|
|
id: SpanId, |
|
|
is_graph: bool, |
|
|
start: Timestamp, |
|
|
end: Timestamp, |
|
|
duration: Timestamp, |
|
|
cpu: Timestamp, |
|
|
allocations: u64, |
|
|
deallocations: u64, |
|
|
allocation_count: u64, |
|
|
persistent_allocations: u64, |
|
|
args: Vec<(String, String)>, |
|
|
path: Vec<String>, |
|
|
}, |
|
|
} |
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug)] |
|
|
#[serde(tag = "type")] |
|
|
#[serde(rename_all = "kebab-case")] |
|
|
pub enum ClientToServerMessage { |
|
|
#[serde(rename_all = "camelCase")] |
|
|
ViewRect { |
|
|
view_rect: ViewRect, |
|
|
}, |
|
|
ViewMode { |
|
|
#[serde(with = "u64_string")] |
|
|
id: SpanId, |
|
|
mode: String, |
|
|
inherit: bool, |
|
|
}, |
|
|
ResetViewMode { |
|
|
#[serde(with = "u64_string")] |
|
|
id: SpanId, |
|
|
}, |
|
|
Query { |
|
|
#[serde(with = "u64_string")] |
|
|
id: SpanId, |
|
|
}, |
|
|
Ack, |
|
|
CheckForMoreData, |
|
|
} |
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug)] |
|
|
#[serde(rename_all = "camelCase")] |
|
|
pub struct SpanViewEvent { |
|
|
pub start: Timestamp, |
|
|
pub duration: Timestamp, |
|
|
pub name: String, |
|
|
pub id: Option<SpanId>, |
|
|
} |
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug)] |
|
|
pub struct Filter { |
|
|
pub op: Op, |
|
|
pub value: u64, |
|
|
} |
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug)] |
|
|
#[serde(rename_all = "snake_case")] |
|
|
pub enum Op { |
|
|
Gt, |
|
|
Lt, |
|
|
} |
|
|
|
|
|
#[derive(Serialize, Deserialize, Debug)] |
|
|
#[serde(rename_all = "camelCase")] |
|
|
pub struct ViewRect { |
|
|
pub x: u64, |
|
|
pub y: u64, |
|
|
pub width: u64, |
|
|
pub height: u64, |
|
|
pub horizontal_pixels: u64, |
|
|
pub query: String, |
|
|
pub view_mode: String, |
|
|
pub value_mode: String, |
|
|
pub value_filter: Option<Filter>, |
|
|
pub count_filter: Option<Filter>, |
|
|
} |
|
|
|
|
|
struct ConnectionState { |
|
|
store: Arc<StoreContainer>, |
|
|
viewer: Viewer, |
|
|
view_rect: ViewRect, |
|
|
last_update_generation: usize, |
|
|
} |
|
|
|
|
|
pub fn serve(store: Arc<StoreContainer>, port: u16) { |
|
|
let server = TcpListener::bind(SocketAddr::V4(SocketAddrV4::new( |
|
|
std::net::Ipv4Addr::new(127, 0, 0, 1), |
|
|
port, |
|
|
))) |
|
|
.unwrap(); |
|
|
for stream in server.incoming() { |
|
|
let store = store.clone(); |
|
|
|
|
|
spawn(move || { |
|
|
let websocket = accept(stream.unwrap()).unwrap(); |
|
|
if let Err(err) = handle_connection(websocket, store) { |
|
|
eprintln!("Error: {err:?}"); |
|
|
} |
|
|
}); |
|
|
} |
|
|
} |
|
|
|
|
|
fn handle_connection( |
|
|
mut websocket: tungstenite::WebSocket<TcpStream>, |
|
|
store: Arc<StoreContainer>, |
|
|
) -> Result<()> { |
|
|
let state = Arc::new(Mutex::new(ConnectionState { |
|
|
store, |
|
|
viewer: Viewer::new(), |
|
|
view_rect: ViewRect { |
|
|
x: 0, |
|
|
y: 0, |
|
|
width: 1, |
|
|
height: 1, |
|
|
horizontal_pixels: 1, |
|
|
query: String::new(), |
|
|
view_mode: "aggregated".to_string(), |
|
|
value_mode: "duration".to_string(), |
|
|
count_filter: None, |
|
|
value_filter: None, |
|
|
}, |
|
|
last_update_generation: 0, |
|
|
})); |
|
|
let mut update_skipped = false; |
|
|
let mut ready_for_update = true; |
|
|
|
|
|
fn send_update( |
|
|
websocket: &mut tungstenite::WebSocket<TcpStream>, |
|
|
state: &mut ConnectionState, |
|
|
force_send: bool, |
|
|
ready_for_update: &mut bool, |
|
|
update_skipped: &mut bool, |
|
|
) -> Result<()> { |
|
|
if !*ready_for_update { |
|
|
if force_send { |
|
|
*update_skipped = true; |
|
|
} |
|
|
return Ok(()); |
|
|
} |
|
|
let store = state.store.read(); |
|
|
if !force_send && state.last_update_generation == store.generation() { |
|
|
return Ok(()); |
|
|
} |
|
|
state.last_update_generation = store.generation(); |
|
|
let Update { |
|
|
lines: updates, |
|
|
max, |
|
|
} = state.viewer.compute_update(&store, &state.view_rect); |
|
|
let count = updates.len(); |
|
|
for update in updates { |
|
|
let message = ServerToClientMessage::ViewLine { update }; |
|
|
let message = serde_json::to_string(&message).unwrap(); |
|
|
websocket.send(Message::Text(message))?; |
|
|
} |
|
|
let message = ServerToClientMessage::ViewLinesCount { count, max }; |
|
|
let message = serde_json::to_string(&message).unwrap(); |
|
|
websocket.send(Message::Text(message))?; |
|
|
*ready_for_update = false; |
|
|
Ok(()) |
|
|
} |
|
|
loop { |
|
|
match websocket.read()? { |
|
|
Message::Frame(_frame) => {} |
|
|
Message::Text(text) => { |
|
|
let message: ClientToServerMessage = serde_json::from_str(&text)?; |
|
|
let mut state = state.lock().unwrap(); |
|
|
match message { |
|
|
ClientToServerMessage::CheckForMoreData => { |
|
|
send_update( |
|
|
&mut websocket, |
|
|
&mut state, |
|
|
false, |
|
|
&mut ready_for_update, |
|
|
&mut update_skipped, |
|
|
)?; |
|
|
} |
|
|
ClientToServerMessage::ViewRect { view_rect } => { |
|
|
state.view_rect = view_rect; |
|
|
send_update( |
|
|
&mut websocket, |
|
|
&mut state, |
|
|
true, |
|
|
&mut ready_for_update, |
|
|
&mut update_skipped, |
|
|
)?; |
|
|
} |
|
|
ClientToServerMessage::ViewMode { id, mode, inherit } => { |
|
|
let (mode, sorted) = if let Some(mode) = mode.strip_suffix("-sorted") { |
|
|
(mode, true) |
|
|
} else { |
|
|
(mode.as_str(), false) |
|
|
}; |
|
|
match mode { |
|
|
"raw-spans" => { |
|
|
state.viewer.set_view_mode( |
|
|
id, |
|
|
Some((ViewMode::RawSpans { sorted }, inherit)), |
|
|
); |
|
|
} |
|
|
"aggregated" => { |
|
|
state.viewer.set_view_mode( |
|
|
id, |
|
|
Some((ViewMode::Aggregated { sorted }, inherit)), |
|
|
); |
|
|
} |
|
|
"bottom-up" => { |
|
|
state.viewer.set_view_mode( |
|
|
id, |
|
|
Some((ViewMode::BottomUp { sorted }, inherit)), |
|
|
); |
|
|
} |
|
|
"aggregated-bottom-up" => { |
|
|
state.viewer.set_view_mode( |
|
|
id, |
|
|
Some((ViewMode::AggregatedBottomUp { sorted }, inherit)), |
|
|
); |
|
|
} |
|
|
_ => { |
|
|
bail!("unknown view mode: {}", mode) |
|
|
} |
|
|
} |
|
|
send_update( |
|
|
&mut websocket, |
|
|
&mut state, |
|
|
true, |
|
|
&mut ready_for_update, |
|
|
&mut update_skipped, |
|
|
)?; |
|
|
} |
|
|
ClientToServerMessage::ResetViewMode { id } => { |
|
|
state.viewer.set_view_mode(id, None); |
|
|
send_update( |
|
|
&mut websocket, |
|
|
&mut state, |
|
|
true, |
|
|
&mut ready_for_update, |
|
|
&mut update_skipped, |
|
|
)?; |
|
|
} |
|
|
ClientToServerMessage::Query { id } => { |
|
|
let message = { |
|
|
let store = state.store.read(); |
|
|
if let Some((span, is_graph)) = store.span(id) { |
|
|
let root_start = store.root_span().start(); |
|
|
let span_start = span.start() - root_start; |
|
|
let span_end = span.end() - root_start; |
|
|
let duration = span.corrected_total_time(); |
|
|
let cpu = span.total_time(); |
|
|
let allocations = span.total_allocations(); |
|
|
let deallocations = span.total_deallocations(); |
|
|
let allocation_count = span.total_allocation_count(); |
|
|
let persistent_allocations = span.total_persistent_allocations(); |
|
|
let args = span |
|
|
.args() |
|
|
.map(|(k, v)| (k.to_string(), v.to_string())) |
|
|
.collect(); |
|
|
let mut path = Vec::new(); |
|
|
let mut current = span; |
|
|
while let Some(parent) = current.parent() { |
|
|
path.push(parent.nice_name().1.to_string()); |
|
|
current = parent; |
|
|
} |
|
|
path.reverse(); |
|
|
ServerToClientMessage::QueryResult { |
|
|
id, |
|
|
is_graph, |
|
|
start: span_start, |
|
|
end: span_end, |
|
|
duration, |
|
|
cpu, |
|
|
allocations, |
|
|
deallocations, |
|
|
allocation_count, |
|
|
persistent_allocations, |
|
|
args, |
|
|
path, |
|
|
} |
|
|
} else { |
|
|
ServerToClientMessage::QueryResult { |
|
|
id, |
|
|
is_graph: false, |
|
|
start: Timestamp::ZERO, |
|
|
end: Timestamp::ZERO, |
|
|
duration: Timestamp::ZERO, |
|
|
cpu: Timestamp::ZERO, |
|
|
allocations: 0, |
|
|
deallocations: 0, |
|
|
allocation_count: 0, |
|
|
persistent_allocations: 0, |
|
|
args: Vec::new(), |
|
|
path: Vec::new(), |
|
|
} |
|
|
} |
|
|
}; |
|
|
let message = serde_json::to_string(&message).unwrap(); |
|
|
websocket.send(Message::Text(message))?; |
|
|
send_update( |
|
|
&mut websocket, |
|
|
&mut state, |
|
|
true, |
|
|
&mut ready_for_update, |
|
|
&mut update_skipped, |
|
|
)?; |
|
|
|
|
|
continue; |
|
|
} |
|
|
ClientToServerMessage::Ack => { |
|
|
ready_for_update = true; |
|
|
if update_skipped { |
|
|
update_skipped = false; |
|
|
send_update( |
|
|
&mut websocket, |
|
|
&mut state, |
|
|
true, |
|
|
&mut ready_for_update, |
|
|
&mut update_skipped, |
|
|
)?; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
Message::Binary(_) => { |
|
|
|
|
|
} |
|
|
Message::Close(_) => { |
|
|
return Ok(()); |
|
|
} |
|
|
Message::Ping(d) => { |
|
|
websocket.send(Message::Pong(d))?; |
|
|
} |
|
|
Message::Pong(_) => { |
|
|
|
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
