Add tracing-trace

tracing-trace/src/processor/firefox_profiler.rs

@@ -0,0 +1,255 @@
+use std::collections::HashMap;
+
+use fxprof_processed_profile::{
+    CategoryPairHandle, CpuDelta, Frame, FrameFlags, FrameInfo, MarkerDynamicField,
+    MarkerFieldFormat, MarkerLocation, MarkerSchema, MarkerSchemaField, Profile, ProfilerMarker,
+    ReferenceTimestamp, SamplingInterval, StringHandle, Timestamp,
+};
+use serde_json::json;
+
+use crate::entry::{
+    Entry, NewCallsite, NewSpan, ResourceId, SpanClose, SpanEnter, SpanExit, SpanId,
+};
+use crate::{Error, TraceReader};
+
+pub fn to_firefox_profile<R: std::io::Read>(
+    trace: TraceReader<R>,
+    app: &str,
+) -> Result<Profile, Error> {
+    let mut profile = Profile::new(
+        app,
+        ReferenceTimestamp::from_millis_since_unix_epoch(0.0),
+        SamplingInterval::from_nanos(15),
+    );
+
+    let mut last_timestamp = Timestamp::from_nanos_since_reference(0);
+    let main = profile.add_process(app, 0, last_timestamp);
+
+    let mut calls = HashMap::new();
+    let mut threads = HashMap::new();
+    let mut spans = HashMap::new();
+
+    let category = profile.add_category("general", fxprof_processed_profile::CategoryColor::Blue);
+    let subcategory = profile.add_subcategory(category, "subcategory");
+
+    // TODO kero: add counters profile.add_counters + last_memory_value
+
+    for entry in trace {
+        let entry = entry?;
+        match entry {
+            Entry::NewCallsite(callsite) => {
+                let string_handle = profile.intern_string(callsite.name.as_ref());
+                calls.insert(callsite.call_id, (callsite, string_handle));
+            }
+            Entry::NewThread(thread) => {
+                let thread_handle = profile.add_thread(
+                    main,
+                    thread.thread_id.to_usize() as u32,
+                    last_timestamp,
+                    threads.is_empty(),
+                );
+                if let Some(name) = &thread.name {
+                    profile.set_thread_name(thread_handle, name)
+                }
+                threads.insert(thread.thread_id, thread_handle);
+            }
+            Entry::NewSpan(span) => {
+                spans.insert(span.id, (span, SpanStatus::Outside));
+            }
+            Entry::SpanEnter(SpanEnter { id, time }) => {
+                let (_span, status) = spans.get_mut(&id).unwrap();
+
+                let SpanStatus::Outside = status else {
+                    continue;
+                };
+
+                *status = SpanStatus::Inside(time);
+
+                last_timestamp = Timestamp::from_nanos_since_reference(time.as_nanos() as u64);
+
+                /* TODO kero: compute delta and update them
+                profile.add_counter_sample(
+                    counter,
+                    timestamp,
+                    value_delta,
+                    number_of_operations_delta,
+                )
+                */
+            }
+            Entry::SpanExit(SpanExit { id, time }) => {
+                let (span, status) = spans.get_mut(&id).unwrap();
+
+                let SpanStatus::Inside(begin) = status else {
+                    continue;
+                };
+                last_timestamp = Timestamp::from_nanos_since_reference(time.as_nanos() as u64);
+
+                let begin = *begin;
+
+                *status = SpanStatus::Outside;
+
+                let span = *span;
+                let thread_handle = threads.get(&span.thread_id).unwrap();
+
+                let frames = make_frames(span, &spans, &calls, subcategory);
+
+                profile.add_sample(
+                    *thread_handle,
+                    to_timestamp(begin),
+                    frames.iter().rev().cloned(),
+                    CpuDelta::ZERO,
+                    1,
+                );
+                profile.add_sample(
+                    *thread_handle,
+                    to_timestamp(time),
+                    frames.iter().rev().cloned(),
+                    CpuDelta::from_nanos((time - begin).as_nanos() as u64),
+                    1,
+                );
+
+                /* TODO kero: compute delta and update them
+                profile.add_counter_sample(
+                    counter,
+                    timestamp,
+                    value_delta,
+                    number_of_operations_delta,
+                )
+                */
+
+                let (callsite, _) = calls.get(&span.call_id).unwrap();
+
+                let marker = SpanMarker { callsite, span: &span };
+
+                profile.add_marker_with_stack(
+                    *thread_handle,
+                    &callsite.name,
+                    marker,
+                    fxprof_processed_profile::MarkerTiming::Interval(
+                        to_timestamp(begin),
+                        to_timestamp(time),
+                    ),
+                    frames.iter().rev().cloned(),
+                )
+            }
+            Entry::SpanClose(SpanClose { id, time }) => {
+                spans.remove(&id);
+                last_timestamp = Timestamp::from_nanos_since_reference(time.as_nanos() as u64);
+            }
+        }
+    }
+
+    Ok(profile)
+}
+
+fn to_timestamp(time: std::time::Duration) -> Timestamp {
+    Timestamp::from_nanos_since_reference(time.as_nanos() as u64)
+}
+
+fn make_frames(
+    span: NewSpan,
+    spans: &HashMap<SpanId, (NewSpan, SpanStatus)>,
+    calls: &HashMap<ResourceId, (NewCallsite, StringHandle)>,
+    subcategory: CategoryPairHandle,
+) -> Vec<FrameInfo> {
+    let mut frames = Vec::new();
+    let mut current_span = span;
+    loop {
+        let frame = make_frame(current_span, calls, subcategory);
+        frames.push(frame);
+        if let Some(parent) = current_span.parent_id {
+            current_span = spans.get(&parent).unwrap().0;
+        } else {
+            break;
+        }
+    }
+    frames
+}
+
+fn make_frame(
+    span: NewSpan,
+    calls: &HashMap<ResourceId, (NewCallsite, StringHandle)>,
+    subcategory: CategoryPairHandle,
+) -> FrameInfo {
+    let (_, call) = calls.get(&span.call_id).unwrap();
+    FrameInfo { frame: Frame::Label(*call), category_pair: subcategory, flags: FrameFlags::empty() }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum SpanStatus {
+    Outside,
+    Inside(std::time::Duration),
+}
+
+struct SpanMarker<'a> {
+    span: &'a NewSpan,
+    callsite: &'a NewCallsite,
+}
+
+impl<'a> ProfilerMarker for SpanMarker<'a> {
+    const MARKER_TYPE_NAME: &'static str = "span";
+
+    fn schema() -> MarkerSchema {
+        let fields = vec![
+            MarkerSchemaField::Dynamic(MarkerDynamicField {
+                key: "filename",
+                label: "File name",
+                format: MarkerFieldFormat::FilePath,
+                searchable: true,
+            }),
+            MarkerSchemaField::Dynamic(MarkerDynamicField {
+                key: "line",
+                label: "Line",
+                format: MarkerFieldFormat::Integer,
+                searchable: true,
+            }),
+            MarkerSchemaField::Dynamic(MarkerDynamicField {
+                key: "module_path",
+                label: "Module path",
+                format: MarkerFieldFormat::String,
+                searchable: true,
+            }),
+            MarkerSchemaField::Dynamic(MarkerDynamicField {
+                key: "span_id",
+                label: "Span ID",
+                format: MarkerFieldFormat::Integer,
+                searchable: true,
+            }),
+            MarkerSchemaField::Dynamic(MarkerDynamicField {
+                key: "thread_id",
+                label: "Thread ID",
+                format: MarkerFieldFormat::Integer,
+                searchable: true,
+            }),
+        ];
+
+        MarkerSchema {
+            type_name: Self::MARKER_TYPE_NAME,
+            locations: vec![
+                MarkerLocation::MarkerTable,
+                MarkerLocation::MarkerChart,
+                MarkerLocation::TimelineOverview,
+            ],
+            chart_label: None,
+            tooltip_label: Some("{marker.name} - {marker.data.filename}:{marker.data.line}"),
+            table_label: Some("{marker.data.filename}:{marker.data.line}"),
+            fields,
+        }
+    }
+
+    fn json_marker_data(&self) -> serde_json::Value {
+        let filename = self.callsite.file.as_deref();
+        let line = self.callsite.line;
+        let module_path = self.callsite.module_path.as_deref();
+        let span_id = self.span.id;
+        let thread_id = self.span.thread_id;
+        json!({
+            "type": Self::MARKER_TYPE_NAME,
+            "filename": filename,
+            "line": line,
+            "module_path": module_path,
+            "span_id": span_id,
+            "thread_id": thread_id,
+        })
+    }
+}

tracing-trace/src/processor/fmt.rs

@@ -0,0 +1,128 @@
+use std::collections::HashMap;
+use std::io::Read;
+
+use crate::entry::{
+    Entry, NewCallsite, NewSpan, NewThread, ResourceId, SpanClose, SpanEnter, SpanExit, SpanId,
+};
+use crate::{Error, TraceReader};
+
+#[derive(Debug, Clone, Copy)]
+enum SpanStatus {
+    Outside,
+    Inside(std::time::Duration),
+}
+
+pub fn print_trace<R: Read>(trace: TraceReader<R>) -> Result<(), Error> {
+    let mut calls = HashMap::new();
+    let mut threads = HashMap::new();
+    let mut spans = HashMap::new();
+    for entry in trace {
+        let entry = entry?;
+        match entry {
+            Entry::NewCallsite(callsite) => {
+                calls.insert(callsite.call_id, callsite);
+            }
+            Entry::NewThread(NewThread { thread_id, name }) => {
+                threads.insert(thread_id, name);
+            }
+            Entry::NewSpan(span) => {
+                spans.insert(span.id, (span, SpanStatus::Outside));
+            }
+            Entry::SpanEnter(SpanEnter { id, time }) => {
+                let (span, status) = spans.get_mut(&id).unwrap();
+
+                let SpanStatus::Outside = status else {
+                    continue;
+                };
+
+                *status = SpanStatus::Inside(time);
+
+                let span = *span;
+
+                println!(
+                    "[{}]{}::{} <-",
+                    print_thread(&threads, span.thread_id),
+                    print_backtrace(&spans, &calls, &span),
+                    print_span(&calls, &span)
+                );
+            }
+            Entry::SpanExit(SpanExit { id, time }) => {
+                let (span, status) = spans.get_mut(&id).unwrap();
+
+                let SpanStatus::Inside(begin) = status else {
+                    continue;
+                };
+                let begin = *begin;
+
+                *status = SpanStatus::Outside;
+
+                let span = *span;
+
+                println!(
+                    "[{}]{}::{} -> {}",
+                    print_thread(&threads, span.thread_id),
+                    print_backtrace(&spans, &calls, &span),
+                    print_span(&calls, &span),
+                    print_duration(time - begin),
+                )
+            }
+            Entry::SpanClose(SpanClose { id, time: _ }) => {
+                spans.remove(&id);
+            }
+        }
+    }
+    Ok(())
+}
+
+fn print_thread(threads: &HashMap<ResourceId, Option<String>>, thread_id: ResourceId) -> String {
+    let thread = threads.get(&thread_id).unwrap();
+    let thread =
+        thread.as_ref().cloned().unwrap_or_else(|| format!("ThreadId({})", thread_id.to_usize()));
+    thread
+}
+
+fn print_backtrace(
+    spans: &HashMap<SpanId, (NewSpan, SpanStatus)>,
+    calls: &HashMap<ResourceId, NewCallsite>,
+    span: &NewSpan,
+) -> String {
+    let mut parents = Vec::new();
+    let mut current = span.parent_id;
+    while let Some(current_id) = &current {
+        let (span, _) = spans.get(current_id).unwrap();
+        let callsite = calls.get(&span.call_id).unwrap();
+        parents.push(callsite.name.clone());
+
+        current = span.parent_id;
+    }
+
+    let x: Vec<String> = parents.into_iter().rev().map(|x| x.to_string()).collect();
+    x.join("::")
+}
+
+fn print_span(calls: &HashMap<ResourceId, NewCallsite>, span: &NewSpan) -> String {
+    let callsite = calls.get(&span.call_id).unwrap();
+    match (callsite.file.clone(), callsite.line) {
+        (Some(file), None) => format!("{} ({})", callsite.name, file),
+        (Some(file), Some(line)) => format!("{} ({}:{})", callsite.name, file, line),
+        _ => callsite.name.to_string(),
+    }
+}
+
+fn print_duration(duration: std::time::Duration) -> String {
+    if duration.as_nanos() < 1000 {
+        format!("{}ns", duration.as_nanos())
+    } else if duration.as_micros() < 1000 {
+        format!("{}μs", duration.as_micros())
+    } else if duration.as_millis() < 1000 {
+        format!("{}ms", duration.as_millis())
+    } else if duration.as_secs() < 120 {
+        format!("{}s", duration.as_secs())
+    } else if duration.as_secs_f64() / 60.0 < 60.0 {
+        format!("{}min", duration.as_secs_f64() / 60.0)
+    } else if duration.as_secs_f64() / 3600.0 < 8.0 {
+        format!("{}h", duration.as_secs_f64() / 3600.0)
+    } else {
+        format!("{}d", duration.as_secs_f64() / 3600.0 / 24.0)
+    }
+}

tracing-trace/src/processor/mod.rs

@@ -0,0 +1,2 @@
+pub mod firefox_profiler;
+pub mod fmt;