|
|
use std::{borrow::Cow, fmt::Display, sync::Arc}; |
|
|
|
|
|
use rustc_hash::{FxHashMap, FxHashSet}; |
|
|
use serde::Deserialize; |
|
|
|
|
|
use super::TraceFormat; |
|
|
use crate::{FxIndexMap, span::SpanIndex, store_container::StoreContainer, timestamp::Timestamp}; |
|
|
|
|
|
pub struct NextJsFormat { |
|
|
store: Arc<StoreContainer>, |
|
|
id_mapping: FxHashMap<u64, SpanIndex>, |
|
|
queued_children: FxHashMap<u64, Vec<SpanIndex>>, |
|
|
} |
|
|
|
|
|
impl NextJsFormat { |
|
|
pub fn new(store: Arc<StoreContainer>) -> Self { |
|
|
Self { |
|
|
store, |
|
|
id_mapping: FxHashMap::default(), |
|
|
queued_children: FxHashMap::default(), |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
impl TraceFormat for NextJsFormat { |
|
|
type Reused = (); |
|
|
|
|
|
fn read(&mut self, mut buffer: &[u8], _reuse: &mut Self::Reused) -> anyhow::Result<usize> { |
|
|
let mut bytes_read = 0; |
|
|
let mut outdated_spans = FxHashSet::default(); |
|
|
loop { |
|
|
let Some(line_end) = buffer.iter().position(|b| *b == b'\n') else { |
|
|
break; |
|
|
}; |
|
|
let line = &buffer[..line_end]; |
|
|
buffer = &buffer[line_end + 1..]; |
|
|
bytes_read += line.len() + 1; |
|
|
|
|
|
let spans: Vec<NextJsSpan> = serde_json::from_slice(line)?; |
|
|
|
|
|
let mut store = self.store.write(); |
|
|
|
|
|
for span in spans { |
|
|
let NextJsSpan { |
|
|
name, |
|
|
duration, |
|
|
timestamp, |
|
|
id, |
|
|
parent_id, |
|
|
tags, |
|
|
start_time: _, |
|
|
trace_id: _, |
|
|
} = span; |
|
|
let timestamp = Timestamp::from_micros(timestamp); |
|
|
let duration = Timestamp::from_micros(duration); |
|
|
let (parent, queue_parent) = if let Some(parent) = parent_id { |
|
|
if let Some(parent) = self.id_mapping.get(&parent) { |
|
|
(Some(*parent), None) |
|
|
} else { |
|
|
(None, Some(parent)) |
|
|
} |
|
|
} else { |
|
|
(None, None) |
|
|
}; |
|
|
let index = store.add_span( |
|
|
parent, |
|
|
timestamp, |
|
|
"nextjs".to_string(), |
|
|
name.into_owned(), |
|
|
tags.iter() |
|
|
.map(|(k, v)| { |
|
|
( |
|
|
k.to_string(), |
|
|
v.as_ref().map(|v| v.to_string()).unwrap_or_default(), |
|
|
) |
|
|
}) |
|
|
.collect(), |
|
|
&mut outdated_spans, |
|
|
); |
|
|
self.id_mapping.insert(id, index); |
|
|
if let Some(parent) = queue_parent { |
|
|
self.queued_children.entry(parent).or_default().push(index); |
|
|
} |
|
|
if let Some(children) = self.queued_children.remove(&id) { |
|
|
for child in children { |
|
|
store.set_parent(child, index, &mut outdated_spans); |
|
|
} |
|
|
} |
|
|
store.set_total_time(index, timestamp, duration, &mut outdated_spans); |
|
|
store.complete_span(index); |
|
|
} |
|
|
store.invalidate_outdated_spans(&outdated_spans); |
|
|
drop(store); |
|
|
} |
|
|
Ok(bytes_read) |
|
|
} |
|
|
} |
|
|
|
|
|
#[derive(Debug, Deserialize)] |
|
|
#[serde(untagged)] |
|
|
enum TagValue<'a> { |
|
|
String(Cow<'a, str>), |
|
|
Number(f64), |
|
|
Bool(bool), |
|
|
Array(Vec<TagValue<'a>>), |
|
|
} |
|
|
|
|
|
impl Display for TagValue<'_> { |
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
|
|
match self { |
|
|
TagValue::String(s) => write!(f, "{s}"), |
|
|
TagValue::Number(n) => write!(f, "{n}"), |
|
|
TagValue::Bool(b) => write!(f, "{b}"), |
|
|
TagValue::Array(a) => { |
|
|
write!(f, "[")?; |
|
|
for (i, v) in a.iter().enumerate() { |
|
|
if i > 0 { |
|
|
write!(f, ", ")?; |
|
|
} |
|
|
write!(f, "{v}")?; |
|
|
} |
|
|
write!(f, "]") |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
#[derive(Debug, Deserialize)] |
|
|
#[serde(rename_all = "camelCase")] |
|
|
struct NextJsSpan<'a> { |
|
|
name: Cow<'a, str>, |
|
|
duration: u64, |
|
|
timestamp: u64, |
|
|
id: u64, |
|
|
parent_id: Option<u64>, |
|
|
tags: FxIndexMap<Cow<'a, str>, Option<TagValue<'a>>>, |
|
|
#[allow(dead_code)] |
|
|
start_time: u64, |
|
|
#[allow(dead_code)] |
|
|
trace_id: Cow<'a, str>, |
|
|
} |
|
|
|
