something is working

src/lib.rs

@@ -1,6 +1,83 @@
+use std::{
+    sync::{atomic::AtomicU64, Mutex},
+    time::Instant,
+};
+
+mod perfetto {
+    include!(concat!(env!("OUT_DIR"), "/perfetto.trace.rs"));
+}
+
+use prost::Message;
 use tracing::{span, Subscriber};
 
-struct PerfettoSubscriber {}
+pub struct PerfettoSubscriber {
+    id_counter: AtomicU64,
+    start_time: Instant,
+    writer: Mutex<Vec<perfetto::TracePacket>>,
+}
+
+impl PerfettoSubscriber {
+    pub fn new() -> Self {
+        let mut packets = Vec::new();
+        packets.push(perfetto::TracePacket {
+            timestamp: None,
+            data: Some(perfetto::trace_packet::Data::TrackDescriptor(
+                perfetto::TrackDescriptor {
+                    uuid: Some(894893984),
+                    parent_uuid: None,
+                    static_or_dynamic_name: None,
+                    process: Some(perfetto::ProcessDescriptor {
+                        pid: Some(1234),
+                        process_name: Some(String::from("test")),
+                    }),
+                    thread: None,
+                },
+            )),
+            optional_trusted_packet_sequence_id: Some(
+                perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
+                    3903809,
+                ),
+            ),
+        });
+        packets.push(perfetto::TracePacket {
+            timestamp: None,
+            data: Some(perfetto::trace_packet::Data::TrackDescriptor(
+                perfetto::TrackDescriptor {
+                    uuid: Some(49083589894),
+                    parent_uuid: None,
+                    static_or_dynamic_name: None,
+                    process: None,
+                    thread: Some(perfetto::ThreadDescriptor {
+                        pid: Some(1234),
+                        thread_name: Some(String::from("test_thread")),
+                        tid: Some(10),
+                    }),
+                },
+            )),
+            optional_trusted_packet_sequence_id: Some(
+                perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
+                    3903809,
+                ),
+            ),
+        });
+        Self {
+            id_counter: AtomicU64::new(1),
+            writer: Mutex::new(packets),
+            start_time: Instant::now(),
+        }
+    }
+
+    fn flush(&self) {
+        let mut data = self.writer.lock().unwrap();
+
+        let trace = perfetto::Trace {
+            packet: data.to_vec(),
+        };
+        let buf = trace.encode_to_vec();
+
+        let _ = std::fs::write("out.trace", buf);
+    }
+}
 
 impl Subscriber for PerfettoSubscriber {
     fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool {
@@ -8,26 +85,100 @@ impl Subscriber for PerfettoSubscriber {
     }
 
     fn new_span(&self, span: &span::Attributes<'_>) -> span::Id {
-        todo!()
+        println!("new_span {:?}", span);
+        let id = self
+            .id_counter
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+
+        span::Id::from_u64(id)
     }
 
     fn record(&self, span: &span::Id, values: &span::Record<'_>) {
-        todo!()
+        println!("record {:?} {:?}", span, values);
     }
 
     fn record_follows_from(&self, span: &span::Id, follows: &span::Id) {
-        todo!()
+        println!("record_follows_from {:?} {:?}", span, follows);
     }
 
     fn event(&self, event: &tracing::Event<'_>) {
-        todo!()
+        println!("event {:?}", event);
+        {
+            let time = self.start_time.elapsed().as_nanos() as u64;
+            let mut vec = self.writer.lock().unwrap();
+
+            vec.push(perfetto::TracePacket {
+            timestamp: Some(time),
+            data: Some(perfetto::trace_packet::Data::TrackEvent(
+                perfetto::TrackEvent {
+                    track_uuid: Some(49083589894),
+                    categories: vec![],
+                    category_iids: vec![],
+                    name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
+                    r#type: Some(perfetto::track_event::Type::Instant as i32),
+                },
+            )),
+            optional_trusted_packet_sequence_id: Some(
+                perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
+                    3903809,
+                ),
+            ),
+        });
+        }
+        self.flush();
     }
 
     fn enter(&self, span: &span::Id) {
-        todo!()
+        println!("enter {:?}", span);
+        {
+            let time = self.start_time.elapsed().as_nanos() as u64;
+            let mut vec = self.writer.lock().unwrap();
+
+            vec.push(perfetto::TracePacket {
+            timestamp: Some(time),
+            data: Some(perfetto::trace_packet::Data::TrackEvent(
+                perfetto::TrackEvent {
+                    track_uuid: Some(49083589894),
+                    categories: vec![],
+                    category_iids: vec![],
+                    name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
+                    r#type: Some(perfetto::track_event::Type::SliceBegin as i32),
+                },
+            )),
+            optional_trusted_packet_sequence_id: Some(
+                perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
+                    3903809,
+                ),
+            ),
+        });
+        }
+        self.flush();
     }
 
     fn exit(&self, span: &span::Id) {
-        todo!()
+        println!("exit {:?}", span);
+        {
+            let time = self.start_time.elapsed().as_nanos() as u64;
+            let mut vec = self.writer.lock().unwrap();
+
+            vec.push(perfetto::TracePacket {
+            timestamp: Some(time),
+            data: Some(perfetto::trace_packet::Data::TrackEvent(
+                perfetto::TrackEvent {
+                    track_uuid: Some(49083589894),
+                    categories: vec![],
+                    category_iids: vec![],
+                    name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
+                    r#type: Some(perfetto::track_event::Type::SliceEnd as i32),
+                },
+            )),
+            optional_trusted_packet_sequence_id: Some(
+                perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
+                    3903809,
+                ),
+            ),
+        });
+        }
+        self.flush();
     }
 }

src/main.rs

@@ -1,132 +1,20 @@
-use prost::Message;
+use std::thread::sleep;
 
-mod perfetto {
+use tracing::{span, trace, Dispatch, Level};
-    include!(concat!(env!("OUT_DIR"), "/perfetto.trace.rs"));
-}
 
 fn main() {
-    let mut packets = Vec::new();
+    let subscriber = tracing_perfetto::PerfettoSubscriber::new();
-    packets.push(perfetto::TracePacket {
+    let dispatcher = Dispatch::new(subscriber);
-        timestamp: None,
+    tracing::dispatcher::set_global_default(dispatcher).unwrap();
-        data: Some(perfetto::trace_packet::Data::TrackDescriptor(
-            perfetto::TrackDescriptor {
-                uuid: Some(894893984),
-                parent_uuid: None,
-                static_or_dynamic_name: None,
-                process: Some(perfetto::ProcessDescriptor {
-                    pid: Some(1234),
-                    process_name: Some(String::from("test")),
-                }),
-                thread: None,
-            },
-        )),
-        optional_trusted_packet_sequence_id: Some(
-            perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
-                3903809,
-            ),
-        ),
-    });
-    packets.push(perfetto::TracePacket {
-        timestamp: None,
-        data: Some(perfetto::trace_packet::Data::TrackDescriptor(
-            perfetto::TrackDescriptor {
-                uuid: Some(49083589894),
-                parent_uuid: None,
-                static_or_dynamic_name: None,
-                process: None,
-                thread: Some(perfetto::ThreadDescriptor {
-                    pid: Some(1234),
-                    thread_name: Some(String::from("test_thread")),
-                    tid: Some(10),
-                }),
-            },
-        )),
-        optional_trusted_packet_sequence_id: Some(
-            perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
-                3903809,
-            ),
-        ),
-    });
 
-    packets.push(perfetto::TracePacket {
+    let _outer_span = span!(Level::TRACE, "test").entered();
-        timestamp: Some(100),
+    sleep(std::time::Duration::from_millis(10));
-        data: Some(perfetto::trace_packet::Data::TrackEvent(
+    {
-            perfetto::TrackEvent {
+        let _inner_span = span!(Level::TRACE, "test1").entered();
-                track_uuid: Some(49083589894),
+        sleep(std::time::Duration::from_millis(10));
-                categories: vec![],
+        trace!("event");
-                category_iids: vec![],
-                name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
-                r#type: Some(perfetto::track_event::Type::Instant as i32),
-            },
-        )),
-        optional_trusted_packet_sequence_id: Some(
-            perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
-                3903809,
-            ),
-        ),
-    });
 
-    packets.push(perfetto::TracePacket {
+        sleep(std::time::Duration::from_millis(10));
-        timestamp: Some(200),
+    }
-        data: Some(perfetto::trace_packet::Data::TrackEvent(
+    sleep(std::time::Duration::from_millis(10));
-            perfetto::TrackEvent {
-                track_uuid: Some(49083589894),
-                categories: vec![],
-                category_iids: vec![],
-                name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
-                r#type: Some(perfetto::track_event::Type::SliceBegin as i32),
-            },
-        )),
-        optional_trusted_packet_sequence_id: Some(
-            perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
-                3903809,
-            ),
-        ),
-    });
-
-    packets.push(perfetto::TracePacket {
-        timestamp: Some(400),
-        data: Some(perfetto::trace_packet::Data::TrackEvent(
-            perfetto::TrackEvent {
-                track_uuid: Some(49083589894),
-                categories: vec![],
-                category_iids: vec![],
-                name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
-                r#type: Some(perfetto::track_event::Type::Instant as i32),
-            },
-        )),
-        optional_trusted_packet_sequence_id: Some(
-            perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
-                3903809,
-            ),
-        ),
-    });
-
-    packets.push(perfetto::TracePacket {
-        timestamp: Some(600),
-        data: Some(perfetto::trace_packet::Data::TrackEvent(
-            perfetto::TrackEvent {
-                track_uuid: Some(49083589894),
-                categories: vec![],
-                category_iids: vec![],
-                name_field: Some(perfetto::track_event::NameField::Name(String::from("Test"))),
-                r#type: Some(perfetto::track_event::Type::SliceEnd as i32),
-            },
-        )),
-        optional_trusted_packet_sequence_id: Some(
-            perfetto::trace_packet::OptionalTrustedPacketSequenceId::TrustedPacketSequenceId(
-                3903809,
-            ),
-        ),
-    });
-
-    let trace = perfetto::Trace { packet: packets };
-
-    let mut buf = Vec::with_capacity(trace.encoded_len());
-
-    trace.encode(&mut buf).unwrap();
-
-    std::fs::write("out.trace", buf);
-
-    dbg!(trace);
 }