From 1a17bb4c2f38ccf8c766c6859a66357d039510f8 Mon Sep 17 00:00:00 2001
From: Michael Woerister <michaelwoerister@posteo>
Date: Mon, 16 Dec 2019 16:28:44 +0100
Subject: [PATCH 1/3] Add support of having arguments on events.

This is implemented by encoding arguments as part of the event_id.
---
 analyzeme/src/event.rs          | 146 +++++++++++++++++++++++++++++++-
 analyzeme/src/profiling_data.rs |  15 ++--
 analyzeme/src/testing_common.rs |  62 ++++++++++----
 measureme/src/event_id.rs       |  40 +++++++++
 measureme/src/file_header.rs    |   2 +-
 measureme/src/lib.rs            |   2 +
 6 files changed, 244 insertions(+), 23 deletions(-)
 create mode 100644 measureme/src/event_id.rs

diff --git a/analyzeme/src/event.rs b/analyzeme/src/event.rs
index 1a0567f..1b475b3 100644
--- a/analyzeme/src/event.rs
+++ b/analyzeme/src/event.rs
@@ -1,12 +1,16 @@
 use crate::timestamp::Timestamp;
+use memchr::memchr;
 use std::borrow::Cow;
 use std::time::Duration;
 
+const SEPARATOR: u8 = 0x1E;
+const ARG_TAG: u8 = 0x11;
+
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct Event<'a> {
     pub event_kind: Cow<'a, str>,
     pub label: Cow<'a, str>,
-    pub additional_data: &'a [Cow<'a, str>],
+    pub additional_data: Vec<Cow<'a, str>>,
     pub timestamp: Timestamp,
     pub thread_id: u32,
 }
@@ -36,4 +40,144 @@ impl<'a> Event<'a> {
             Timestamp::Instant(_) => None,
         }
     }
+
+    pub(crate) fn parse_event_id(event_id: Cow<'a, str>) -> (Cow<'a, str>, Vec<Cow<'a, str>>) {
+        let event_id = match event_id {
+            Cow::Owned(s) => Cow::Owned(s.into_bytes()),
+            Cow::Borrowed(s) => Cow::Borrowed(s.as_bytes()),
+        };
+
+        let mut parser = Parser::new(event_id);
+
+        let label = match parser.parse_label() {
+            Ok(label) => label,
+            Err(message) => {
+                eprintln!("{}", message);
+                return (Cow::from("<parse error>"), Vec::new());
+            }
+        };
+
+        let mut args = Vec::new();
+
+        while parser.pos != parser.full_text.len() {
+            match parser.parse_arg() {
+                Ok(arg) => args.push(arg),
+                Err(message) => {
+                    eprintln!("{}", message);
+                    break;
+                }
+            }
+        }
+
+        (label, args)
+    }
+}
+
+struct Parser<'a> {
+    full_text: Cow<'a, [u8]>,
+    pos: usize,
+}
+
+impl<'a> Parser<'a> {
+    fn new(full_text: Cow<'a, [u8]>) -> Parser<'a> {
+        Parser { full_text, pos: 0 }
+    }
+
+    fn peek(&self) -> u8 {
+        self.full_text[self.pos]
+    }
+
+    fn parse_label(&mut self) -> Result<Cow<'a, str>, String> {
+        assert!(self.pos == 0);
+        self.parse_separator_terminated_text()
+    }
+
+    fn parse_separator_terminated_text(&mut self) -> Result<Cow<'a, str>, String> {
+        let start = self.pos;
+
+        let end = memchr(SEPARATOR, &self.full_text[start..])
+            .map(|pos| pos + start)
+            .unwrap_or(self.full_text.len());
+
+        if start == end {
+            return self.err("Zero-length <text>");
+        }
+
+        self.pos = end;
+
+        Ok(self.substring(start, end))
+    }
+
+    fn parse_arg(&mut self) -> Result<Cow<'a, str>, String> {
+        if self.peek() != SEPARATOR {
+            return self.err(&format!(
+                "Expected '\\x{:x}' char at start of <argument>",
+                SEPARATOR
+            ));
+        }
+
+        self.pos += 1;
+        let tag = self.peek();
+
+        match tag {
+            ARG_TAG => {
+                self.pos += 1;
+                self.parse_separator_terminated_text()
+            }
+            other => self.err(&format!("Unexpected argument tag '{:x}'", other)),
+        }
+    }
+
+    fn err<T>(&self, message: &str) -> Result<T, String> {
+        Err(format!(
+            r#"Could not parse `event_id`. {} at {} in "{}""#,
+            message,
+            self.pos,
+            std::str::from_utf8(&self.full_text[..]).unwrap()
+        ))
+    }
+
+    fn substring(&self, start: usize, end: usize) -> Cow<'a, str> {
+        match self.full_text {
+            Cow::Owned(ref s) => {
+                let bytes = s[start..end].to_owned();
+                Cow::Owned(String::from_utf8(bytes).unwrap())
+            }
+            Cow::Borrowed(s) => Cow::Borrowed(std::str::from_utf8(&s[start..end]).unwrap()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::borrow::Cow;
+
+    #[test]
+    fn parse_event_id_no_args() {
+        let (label, args) = Event::parse_event_id(Cow::from("foo"));
+
+        assert_eq!(label, "foo");
+        assert!(args.is_empty());
+    }
+
+    #[test]
+    fn parse_event_id_one_arg() {
+        let (label, args) = Event::parse_event_id(Cow::from("foo\x1e\x11my_arg"));
+
+        assert_eq!(label, "foo");
+        assert_eq!(args, vec![Cow::from("my_arg")]);
+    }
+
+    #[test]
+    fn parse_event_id_n_args() {
+        let (label, args) =
+            Event::parse_event_id(Cow::from("foo\x1e\x11arg1\x1e\x11arg2\x1e\x11arg3"));
+
+        assert_eq!(label, "foo");
+        assert_eq!(
+            args,
+            vec![Cow::from("arg1"), Cow::from("arg2"), Cow::from("arg3")]
+        );
+    }
 }
diff --git a/analyzeme/src/profiling_data.rs b/analyzeme/src/profiling_data.rs
index 9325fc1..134c1d4 100644
--- a/analyzeme/src/profiling_data.rs
+++ b/analyzeme/src/profiling_data.rs
@@ -1,7 +1,7 @@
 use crate::event::Event;
 use crate::lightweight_event::LightweightEvent;
-use crate::StringTable;
 use crate::timestamp::Timestamp;
+use crate::StringTable;
 use measureme::file_header::{
     read_file_header, write_file_header, CURRENT_FILE_FORMAT_VERSION, FILE_HEADER_SIZE,
     FILE_MAGIC_EVENT_STREAM,
@@ -94,10 +94,14 @@ impl ProfilingData {
 
         let timestamp = Timestamp::from_raw_event(&raw_event, self.metadata.start_time);
 
+        let event_id = string_table.get(raw_event.event_id).to_string();
+        // Parse out the label and arguments from the `event_id`.
+        let (label, additional_data) = Event::parse_event_id(event_id);
+
         Event {
             event_kind: string_table.get(raw_event.event_kind).to_string(),
-            label: string_table.get(raw_event.event_id).to_string(),
-            additional_data: &[],
+            label,
+            additional_data,
             timestamp,
             thread_id: raw_event.thread_id,
         }
@@ -319,7 +323,7 @@ mod tests {
         Event {
             event_kind: Cow::from(event_kind),
             label: Cow::from(label),
-            additional_data: &[],
+            additional_data: Vec::new(),
             timestamp: Timestamp::Interval {
                 start: SystemTime::UNIX_EPOCH + Duration::from_nanos(start_nanos),
                 end: SystemTime::UNIX_EPOCH + Duration::from_nanos(end_nanos),
@@ -337,7 +341,7 @@ mod tests {
         Event {
             event_kind: Cow::from(event_kind),
             label: Cow::from(label),
-            additional_data: &[],
+            additional_data: Vec::new(),
             timestamp: Timestamp::Instant(
                 SystemTime::UNIX_EPOCH + Duration::from_nanos(timestamp_nanos),
             ),
@@ -399,7 +403,6 @@ mod tests {
         assert_eq!(events[0].to_event(), full_interval("k1", "id1", 0, 10, 100));
         assert_eq!(events[1].to_event(), full_interval("k2", "id2", 1, 100, 110));
         assert_eq!(events[2].to_event(), full_interval("k3", "id3", 0, 120, 140));
-
     }
 
     #[test]
diff --git a/analyzeme/src/testing_common.rs b/analyzeme/src/testing_common.rs
index 976f7a3..08cfdd0 100644
--- a/analyzeme/src/testing_common.rs
+++ b/analyzeme/src/testing_common.rs
@@ -1,6 +1,6 @@
 use crate::timestamp::Timestamp;
 use crate::{Event, ProfilingData};
-use measureme::{Profiler, SerializationSink, StringId};
+use measureme::{EventIdBuilder, Profiler, SerializationSink, StringId};
 use rustc_hash::FxHashMap;
 use std::borrow::Cow;
 use std::default::Default;
@@ -18,6 +18,27 @@ fn mk_filestem(file_name_stem: &str) -> PathBuf {
     path
 }
 
+#[derive(Clone)]
+struct ExpectedEvent {
+    kind: Cow<'static, str>,
+    label: Cow<'static, str>,
+    args: Vec<Cow<'static, str>>,
+}
+
+impl ExpectedEvent {
+    fn new(
+        kind: &'static str,
+        label: &'static str,
+        args: &[&'static str]
+    ) -> ExpectedEvent {
+        ExpectedEvent {
+            kind: Cow::from(kind),
+            label: Cow::from(label),
+            args: args.iter().map(|&x| Cow::from(x)).collect(),
+        }
+    }
+}
+
 // Generate some profiling data. This is the part that would run in rustc.
 fn generate_profiling_data<S: SerializationSink>(
     filestem: &Path,
@@ -28,25 +49,34 @@ fn generate_profiling_data<S: SerializationSink>(
 
     let event_id_virtual = StringId::new_virtual(42);
 
+    let event_id_builder = EventIdBuilder::new(&profiler);
+
     let event_ids = vec![
         (
             profiler.alloc_string("Generic"),
             profiler.alloc_string("SomeGenericActivity"),
         ),
         (profiler.alloc_string("Query"), event_id_virtual),
+        (
+            profiler.alloc_string("QueryWithArg"),
+            event_id_builder.from_label_and_arg(
+                profiler.alloc_string("AQueryWithArg"),
+                profiler.alloc_string("some_arg")
+            ),
+        ),
     ];
 
     // This and event_ids have to match!
-    let mut event_ids_as_str: FxHashMap<_, _> = Default::default();
-    event_ids_as_str.insert(event_ids[0].0, "Generic");
-    event_ids_as_str.insert(event_ids[0].1, "SomeGenericActivity");
-    event_ids_as_str.insert(event_ids[1].0, "Query");
-    event_ids_as_str.insert(event_ids[1].1, "SomeQuery");
+    let expected_events_templates = vec![
+        ExpectedEvent::new("Generic", "SomeGenericActivity", &[]),
+        ExpectedEvent::new("Query", "SomeQuery", &[]),
+        ExpectedEvent::new("QueryWithArg", "AQueryWithArg", &["some_arg"]),
+    ];
 
     let threads: Vec<_> = (0.. num_threads).map(|thread_id| {
         let event_ids = event_ids.clone();
         let profiler = profiler.clone();
-        let event_ids_as_str = event_ids_as_str.clone();
+        let expected_events_templates = expected_events_templates.clone();
 
         std::thread::spawn(move || {
             let mut expected_events = Vec::new();
@@ -60,7 +90,7 @@ fn generate_profiling_data<S: SerializationSink>(
                     thread_id as u32,
                     4,
                     &event_ids[..],
-                    &event_ids_as_str,
+                    &expected_events_templates,
                     &mut expected_events,
                 );
             }
@@ -166,14 +196,16 @@ fn pseudo_invocation<S: SerializationSink>(
     thread_id: u32,
     recursions_left: usize,
     event_ids: &[(StringId, StringId)],
-    event_ids_as_str: &FxHashMap<StringId, &'static str>,
+    expected_events_templates: &[ExpectedEvent],
     expected_events: &mut Vec<Event<'static>>,
 ) {
     if recursions_left == 0 {
         return;
     }
 
-    let (event_kind, event_id) = event_ids[random % event_ids.len()];
+    let random_event_index = random % event_ids.len();
+
+    let (event_kind, event_id) = event_ids[random_event_index];
 
     let _prof_guard = profiler.start_recording_interval_event(event_kind, event_id, thread_id);
 
@@ -183,19 +215,19 @@ fn pseudo_invocation<S: SerializationSink>(
         thread_id,
         recursions_left - 1,
         event_ids,
-        event_ids_as_str,
+        expected_events_templates,
         expected_events,
     );
 
     expected_events.push(Event {
-        event_kind: Cow::from(event_ids_as_str[&event_kind]),
-        label: Cow::from(event_ids_as_str[&event_id]),
-        additional_data: &[],
+        event_kind: expected_events_templates[random_event_index].kind.clone(),
+        label: expected_events_templates[random_event_index].label.clone(),
+        additional_data: expected_events_templates[random_event_index].args.clone(),
+        thread_id,
         // We can't test this anyway:
         timestamp: Timestamp::Interval {
             start: SystemTime::UNIX_EPOCH,
             end: SystemTime::UNIX_EPOCH,
         },
-        thread_id,
     });
 }
diff --git a/measureme/src/event_id.rs b/measureme/src/event_id.rs
new file mode 100644
index 0000000..5a5bdff
--- /dev/null
+++ b/measureme/src/event_id.rs
@@ -0,0 +1,40 @@
+use crate::{Profiler, SerializationSink, StringComponent, StringId};
+
+/// Event IDs are strings conforming to the following grammar:
+///
+/// ```ignore
+///   <event_id> = <label> {<argument>}
+///   <label> = <text>
+///   <argument> = '\x1E' '\x11' <text>
+///   <text> = regex([^0x1E]+) // Anything but the separator byte
+///  ```
+///
+/// This means there's always a "label", followed by an optional list of
+/// arguments. Future versions my support other optional suffixes (with a tag
+/// other than '\x11' after the '\x1E' separator), such as a "category".
+
+pub struct EventIdBuilder<'p, S: SerializationSink> {
+    profiler: &'p Profiler<S>,
+}
+
+impl<'p, S: SerializationSink> EventIdBuilder<'p, S> {
+    pub fn new(profiler: &Profiler<S>) -> EventIdBuilder<'_, S> {
+        EventIdBuilder { profiler }
+    }
+
+    pub fn from_label(&self, label: StringId) -> StringId {
+        // Just forward the string ID, i single identifier is a valid event_id
+        label
+    }
+
+    pub fn from_label_and_arg(&self, label: StringId, arg: StringId) -> StringId {
+        self.profiler.alloc_string(&[
+            // Label
+            StringComponent::Ref(label),
+            // Seperator and start tag for arg
+            StringComponent::Value("\x1E\x11"),
+            // Arg string id
+            StringComponent::Ref(arg),
+        ])
+    }
+}
diff --git a/measureme/src/file_header.rs b/measureme/src/file_header.rs
index 835c623..6fd63f3 100644
--- a/measureme/src/file_header.rs
+++ b/measureme/src/file_header.rs
@@ -6,7 +6,7 @@ use crate::serialization::SerializationSink;
 use byteorder::{ByteOrder, LittleEndian};
 use std::error::Error;
 
-pub const CURRENT_FILE_FORMAT_VERSION: u32 = 4;
+pub const CURRENT_FILE_FORMAT_VERSION: u32 = 5;
 pub const FILE_MAGIC_EVENT_STREAM: &[u8; 4] = b"MMES";
 pub const FILE_MAGIC_STRINGTABLE_DATA: &[u8; 4] = b"MMSD";
 pub const FILE_MAGIC_STRINGTABLE_INDEX: &[u8; 4] = b"MMSI";
diff --git a/measureme/src/lib.rs b/measureme/src/lib.rs
index e26456b..a06f4e7 100644
--- a/measureme/src/lib.rs
+++ b/measureme/src/lib.rs
@@ -37,6 +37,7 @@
 
 #![deny(warnings)]
 
+mod event_id;
 pub mod file_header;
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 mod file_serialization_sink;
@@ -49,6 +50,7 @@ pub mod stringtable;
 
 pub mod rustc;
 
+pub use crate::event_id::EventIdBuilder;
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 pub use crate::file_serialization_sink::FileSerializationSink;
 #[cfg(not(target_arch = "wasm32"))]

From 4968d227ba59fac436c383b866b981b3eba3650f Mon Sep 17 00:00:00 2001
From: Michael Woerister <michaelwoerister@posteo>
Date: Tue, 17 Dec 2019 09:25:38 +0100
Subject: [PATCH 2/3] Simplify event-id grammar by removing the argument tag.

The tag was meant to disambiguate between arguments and other kinds
of annotations (like event category). However, there are only
arguments at the moment, so the tag is redundant. It can be add back
in later.
---
 analyzeme/src/event.rs    | 29 ++++++++++++-----------------
 measureme/src/event_id.rs | 10 +++++++---
 measureme/src/lib.rs      |  2 +-
 3 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/analyzeme/src/event.rs b/analyzeme/src/event.rs
index 1b475b3..a0f02c1 100644
--- a/analyzeme/src/event.rs
+++ b/analyzeme/src/event.rs
@@ -3,9 +3,6 @@ use memchr::memchr;
 use std::borrow::Cow;
 use std::time::Duration;
 
-const SEPARATOR: u8 = 0x1E;
-const ARG_TAG: u8 = 0x11;
-
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct Event<'a> {
     pub event_kind: Cow<'a, str>,
@@ -78,6 +75,8 @@ struct Parser<'a> {
     pos: usize,
 }
 
+const SEPARATOR_BYTE: u8 = measureme::event_id::SEPARATOR_BYTE.as_bytes()[0];
+
 impl<'a> Parser<'a> {
     fn new(full_text: Cow<'a, [u8]>) -> Parser<'a> {
         Parser { full_text, pos: 0 }
@@ -95,7 +94,7 @@ impl<'a> Parser<'a> {
     fn parse_separator_terminated_text(&mut self) -> Result<Cow<'a, str>, String> {
         let start = self.pos;
 
-        let end = memchr(SEPARATOR, &self.full_text[start..])
+        let end = memchr(SEPARATOR_BYTE, &self.full_text[start..])
             .map(|pos| pos + start)
             .unwrap_or(self.full_text.len());
 
@@ -105,27 +104,23 @@ impl<'a> Parser<'a> {
 
         self.pos = end;
 
+        if self.full_text[start .. end].iter().any(u8::is_ascii_control) {
+            return self.err("Found ASCII control character in <text>");
+        }
+
         Ok(self.substring(start, end))
     }
 
     fn parse_arg(&mut self) -> Result<Cow<'a, str>, String> {
-        if self.peek() != SEPARATOR {
+        if self.peek() != SEPARATOR_BYTE {
             return self.err(&format!(
                 "Expected '\\x{:x}' char at start of <argument>",
-                SEPARATOR
+                SEPARATOR_BYTE
             ));
         }
 
         self.pos += 1;
-        let tag = self.peek();
-
-        match tag {
-            ARG_TAG => {
-                self.pos += 1;
-                self.parse_separator_terminated_text()
-            }
-            other => self.err(&format!("Unexpected argument tag '{:x}'", other)),
-        }
+        self.parse_separator_terminated_text()
     }
 
     fn err<T>(&self, message: &str) -> Result<T, String> {
@@ -163,7 +158,7 @@ mod tests {
 
     #[test]
     fn parse_event_id_one_arg() {
-        let (label, args) = Event::parse_event_id(Cow::from("foo\x1e\x11my_arg"));
+        let (label, args) = Event::parse_event_id(Cow::from("foo\x1emy_arg"));
 
         assert_eq!(label, "foo");
         assert_eq!(args, vec![Cow::from("my_arg")]);
@@ -172,7 +167,7 @@ mod tests {
     #[test]
     fn parse_event_id_n_args() {
         let (label, args) =
-            Event::parse_event_id(Cow::from("foo\x1e\x11arg1\x1e\x11arg2\x1e\x11arg3"));
+            Event::parse_event_id(Cow::from("foo\x1earg1\x1earg2\x1earg3"));
 
         assert_eq!(label, "foo");
         assert_eq!(
diff --git a/measureme/src/event_id.rs b/measureme/src/event_id.rs
index 5a5bdff..537d633 100644
--- a/measureme/src/event_id.rs
+++ b/measureme/src/event_id.rs
@@ -5,14 +5,18 @@ use crate::{Profiler, SerializationSink, StringComponent, StringId};
 /// ```ignore
 ///   <event_id> = <label> {<argument>}
 ///   <label> = <text>
-///   <argument> = '\x1E' '\x11' <text>
-///   <text> = regex([^0x1E]+) // Anything but the separator byte
+///   <argument> = '\x1E' <text>
+///   <text> = regex([^[[:cntrl:]]]+) // Anything but ASCII control characters
 ///  ```
 ///
 /// This means there's always a "label", followed by an optional list of
 /// arguments. Future versions my support other optional suffixes (with a tag
 /// other than '\x11' after the '\x1E' separator), such as a "category".
 
+
+/// The byte used to separate arguments from the label and each other.
+pub const SEPARATOR_BYTE: &str = "\x1E";
+
 pub struct EventIdBuilder<'p, S: SerializationSink> {
     profiler: &'p Profiler<S>,
 }
@@ -32,7 +36,7 @@ impl<'p, S: SerializationSink> EventIdBuilder<'p, S> {
             // Label
             StringComponent::Ref(label),
             // Seperator and start tag for arg
-            StringComponent::Value("\x1E\x11"),
+            StringComponent::Value(SEPARATOR_BYTE),
             // Arg string id
             StringComponent::Ref(arg),
         ])
diff --git a/measureme/src/lib.rs b/measureme/src/lib.rs
index a06f4e7..e0cbe36 100644
--- a/measureme/src/lib.rs
+++ b/measureme/src/lib.rs
@@ -37,7 +37,7 @@
 
 #![deny(warnings)]
 
-mod event_id;
+pub mod event_id;
 pub mod file_header;
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 mod file_serialization_sink;

From 9daf790e4fb1cb2608518f7a518e5488b320d14e Mon Sep 17 00:00:00 2001
From: Michael Woerister <michaelwoerister@posteo>
Date: Tue, 17 Dec 2019 10:02:59 +0100
Subject: [PATCH 3/3] Add EventId type that gives additional guarantees on top
 of StringId.

---
 analyzeme/src/event.rs          |  5 ++--
 analyzeme/src/profiling_data.rs | 10 +++++---
 analyzeme/src/stringtable.rs    |  2 +-
 analyzeme/src/testing_common.rs | 21 ++++++----------
 measureme/src/event_id.rs       | 44 +++++++++++++++++++++++++++------
 measureme/src/lib.rs            |  2 +-
 measureme/src/profiler.rs       | 10 ++++----
 measureme/src/raw_event.rs      | 39 +++++++++++++++--------------
 8 files changed, 80 insertions(+), 53 deletions(-)

diff --git a/analyzeme/src/event.rs b/analyzeme/src/event.rs
index a0f02c1..2c548c0 100644
--- a/analyzeme/src/event.rs
+++ b/analyzeme/src/event.rs
@@ -104,7 +104,7 @@ impl<'a> Parser<'a> {
 
         self.pos = end;
 
-        if self.full_text[start .. end].iter().any(u8::is_ascii_control) {
+        if self.full_text[start..end].iter().any(u8::is_ascii_control) {
             return self.err("Found ASCII control character in <text>");
         }
 
@@ -166,8 +166,7 @@ mod tests {
 
     #[test]
     fn parse_event_id_n_args() {
-        let (label, args) =
-            Event::parse_event_id(Cow::from("foo\x1earg1\x1earg2\x1earg3"));
+        let (label, args) = Event::parse_event_id(Cow::from("foo\x1earg1\x1earg2\x1earg3"));
 
         assert_eq!(label, "foo");
         assert_eq!(
diff --git a/analyzeme/src/profiling_data.rs b/analyzeme/src/profiling_data.rs
index 134c1d4..6d08f05 100644
--- a/analyzeme/src/profiling_data.rs
+++ b/analyzeme/src/profiling_data.rs
@@ -7,7 +7,7 @@ use measureme::file_header::{
     FILE_MAGIC_EVENT_STREAM,
 };
 use measureme::ByteVecSink;
-use measureme::{ProfilerFiles, RawEvent, SerializationSink, StringTableBuilder};
+use measureme::{EventId, ProfilerFiles, RawEvent, SerializationSink, StringTableBuilder};
 use serde::{Deserialize, Deserializer};
 use std::error::Error;
 use std::fs;
@@ -94,7 +94,9 @@ impl ProfilingData {
 
         let timestamp = Timestamp::from_raw_event(&raw_event, self.metadata.start_time);
 
-        let event_id = string_table.get(raw_event.event_id).to_string();
+        let event_id = string_table
+            .get(raw_event.event_id.to_string_id())
+            .to_string();
         // Parse out the label and arguments from the `event_id`.
         let (label, additional_data) = Event::parse_event_id(event_id);
 
@@ -230,7 +232,7 @@ impl ProfilingDataBuilder {
         F: FnOnce(&mut Self),
     {
         let event_kind = self.string_table.alloc(event_kind);
-        let event_id = self.string_table.alloc(event_id);
+        let event_id = EventId::from_label(self.string_table.alloc(event_id));
 
         inner(self);
 
@@ -251,7 +253,7 @@ impl ProfilingDataBuilder {
         timestamp_nanos: u64,
     ) -> &mut Self {
         let event_kind = self.string_table.alloc(event_kind);
-        let event_id = self.string_table.alloc(event_id);
+        let event_id = EventId::from_label(self.string_table.alloc(event_id));
 
         let raw_event = RawEvent::new_instant(event_kind, event_id, thread_id, timestamp_nanos);
 
diff --git a/analyzeme/src/stringtable.rs b/analyzeme/src/stringtable.rs
index 86fc99d..2922444 100644
--- a/analyzeme/src/stringtable.rs
+++ b/analyzeme/src/stringtable.rs
@@ -7,10 +7,10 @@ use measureme::file_header::{
 };
 use measureme::stringtable::{METADATA_STRING_ID, STRING_ID_MASK, TERMINATOR};
 use measureme::{Addr, StringId};
+use memchr::memchr;
 use rustc_hash::FxHashMap;
 use std::borrow::Cow;
 use std::error::Error;
-use memchr::memchr;
 
 fn deserialize_index_entry(bytes: &[u8]) -> (StringId, Addr) {
     (
diff --git a/analyzeme/src/testing_common.rs b/analyzeme/src/testing_common.rs
index 08cfdd0..9e9874a 100644
--- a/analyzeme/src/testing_common.rs
+++ b/analyzeme/src/testing_common.rs
@@ -1,6 +1,6 @@
 use crate::timestamp::Timestamp;
 use crate::{Event, ProfilingData};
-use measureme::{EventIdBuilder, Profiler, SerializationSink, StringId};
+use measureme::{EventId, EventIdBuilder, Profiler, SerializationSink, StringId};
 use rustc_hash::FxHashMap;
 use std::borrow::Cow;
 use std::default::Default;
@@ -26,11 +26,7 @@ struct ExpectedEvent {
 }
 
 impl ExpectedEvent {
-    fn new(
-        kind: &'static str,
-        label: &'static str,
-        args: &[&'static str]
-    ) -> ExpectedEvent {
+    fn new(kind: &'static str, label: &'static str, args: &[&'static str]) -> ExpectedEvent {
         ExpectedEvent {
             kind: Cow::from(kind),
             label: Cow::from(label),
@@ -47,21 +43,20 @@ fn generate_profiling_data<S: SerializationSink>(
 ) -> Vec<Event<'static>> {
     let profiler = Arc::new(Profiler::<S>::new(Path::new(filestem)).unwrap());
 
-    let event_id_virtual = StringId::new_virtual(42);
-
+    let event_id_virtual = EventId::from_label(StringId::new_virtual(42));
     let event_id_builder = EventIdBuilder::new(&profiler);
 
-    let event_ids = vec![
+    let event_ids: Vec<(StringId, EventId)> = vec![
         (
             profiler.alloc_string("Generic"),
-            profiler.alloc_string("SomeGenericActivity"),
+            EventId::from_label(profiler.alloc_string("SomeGenericActivity")),
         ),
         (profiler.alloc_string("Query"), event_id_virtual),
         (
             profiler.alloc_string("QueryWithArg"),
             event_id_builder.from_label_and_arg(
                 profiler.alloc_string("AQueryWithArg"),
-                profiler.alloc_string("some_arg")
+                profiler.alloc_string("some_arg"),
             ),
         ),
     ];
@@ -104,7 +99,7 @@ fn generate_profiling_data<S: SerializationSink>(
     // An example of allocating the string contents of an event id that has
     // already been used
     profiler.map_virtual_to_concrete_string(
-        event_id_virtual,
+        event_id_virtual.to_string_id(),
         profiler.alloc_string("SomeQuery")
     );
 
@@ -195,7 +190,7 @@ fn pseudo_invocation<S: SerializationSink>(
     random: usize,
     thread_id: u32,
     recursions_left: usize,
-    event_ids: &[(StringId, StringId)],
+    event_ids: &[(StringId, EventId)],
     expected_events_templates: &[ExpectedEvent],
     expected_events: &mut Vec<Event<'static>>,
 ) {
diff --git a/measureme/src/event_id.rs b/measureme/src/event_id.rs
index 537d633..64af40e 100644
--- a/measureme/src/event_id.rs
+++ b/measureme/src/event_id.rs
@@ -13,10 +13,39 @@ use crate::{Profiler, SerializationSink, StringComponent, StringId};
 /// arguments. Future versions my support other optional suffixes (with a tag
 /// other than '\x11' after the '\x1E' separator), such as a "category".
 
-
 /// The byte used to separate arguments from the label and each other.
 pub const SEPARATOR_BYTE: &str = "\x1E";
 
+/// An `EventId` is a `StringId` with the additional guarantee that the
+/// corresponding string conforms to the event_id grammar.
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+#[repr(C)]
+pub struct EventId(StringId);
+
+impl EventId {
+    pub const INVALID: EventId = EventId(StringId::INVALID);
+
+    #[inline]
+    pub fn to_string_id(self) -> StringId {
+        self.0
+    }
+
+    #[inline]
+    pub fn as_u32(self) -> u32 {
+        self.0.as_u32()
+    }
+
+    #[inline]
+    pub fn from_label(label: StringId) -> EventId {
+        EventId(label)
+    }
+
+    #[inline]
+    pub fn from_virtual(virtual_id: StringId) -> EventId {
+        EventId(virtual_id)
+    }
+}
+
 pub struct EventIdBuilder<'p, S: SerializationSink> {
     profiler: &'p Profiler<S>,
 }
@@ -26,19 +55,20 @@ impl<'p, S: SerializationSink> EventIdBuilder<'p, S> {
         EventIdBuilder { profiler }
     }
 
-    pub fn from_label(&self, label: StringId) -> StringId {
-        // Just forward the string ID, i single identifier is a valid event_id
-        label
+    #[inline]
+    pub fn from_label(&self, label: StringId) -> EventId {
+        // Just forward the string ID, a single identifier is a valid event_id
+        EventId::from_label(label)
     }
 
-    pub fn from_label_and_arg(&self, label: StringId, arg: StringId) -> StringId {
-        self.profiler.alloc_string(&[
+    pub fn from_label_and_arg(&self, label: StringId, arg: StringId) -> EventId {
+        EventId(self.profiler.alloc_string(&[
             // Label
             StringComponent::Ref(label),
             // Seperator and start tag for arg
             StringComponent::Value(SEPARATOR_BYTE),
             // Arg string id
             StringComponent::Ref(arg),
-        ])
+        ]))
     }
 }
diff --git a/measureme/src/lib.rs b/measureme/src/lib.rs
index e0cbe36..1258bb3 100644
--- a/measureme/src/lib.rs
+++ b/measureme/src/lib.rs
@@ -50,7 +50,7 @@ pub mod stringtable;
 
 pub mod rustc;
 
-pub use crate::event_id::EventIdBuilder;
+pub use crate::event_id::{EventId, EventIdBuilder};
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 pub use crate::file_serialization_sink::FileSerializationSink;
 #[cfg(not(target_arch = "wasm32"))]
diff --git a/measureme/src/profiler.rs b/measureme/src/profiler.rs
index bba579b..c63c04d 100644
--- a/measureme/src/profiler.rs
+++ b/measureme/src/profiler.rs
@@ -1,3 +1,4 @@
+use crate::event_id::EventId;
 use crate::file_header::{write_file_header, FILE_MAGIC_EVENT_STREAM};
 use crate::raw_event::RawEvent;
 use crate::serialization::SerializationSink;
@@ -92,7 +93,7 @@ impl<S: SerializationSink> Profiler<S> {
 
     /// Records an event with the given parameters. The event time is computed
     /// automatically.
-    pub fn record_instant_event(&self, event_kind: StringId, event_id: StringId, thread_id: u32) {
+    pub fn record_instant_event(&self, event_kind: StringId, event_id: EventId, thread_id: u32) {
         let raw_event =
             RawEvent::new_instant(event_kind, event_id, thread_id, self.nanos_since_start());
 
@@ -105,7 +106,7 @@ impl<S: SerializationSink> Profiler<S> {
     pub fn start_recording_interval_event<'a>(
         &'a self,
         event_kind: StringId,
-        event_id: StringId,
+        event_id: EventId,
         thread_id: u32,
     ) -> TimingGuard<'a, S> {
         TimingGuard {
@@ -135,7 +136,7 @@ impl<S: SerializationSink> Profiler<S> {
 #[must_use]
 pub struct TimingGuard<'a, S: SerializationSink> {
     profiler: &'a Profiler<S>,
-    event_id: StringId,
+    event_id: EventId,
     event_kind: StringId,
     thread_id: u32,
     start_ns: u64,
@@ -157,11 +158,10 @@ impl<'a, S: SerializationSink> Drop for TimingGuard<'a, S> {
 }
 
 impl<'a, S: SerializationSink> TimingGuard<'a, S> {
-
     /// This method set a new `event_id` right before actually recording the
     /// event.
     #[inline]
-    pub fn finish_with_override_event_id(mut self, event_id: StringId) {
+    pub fn finish_with_override_event_id(mut self, event_id: EventId) {
         self.event_id = event_id;
         // Let's be explicit about it: Dropping the guard will record the event.
         drop(self)
diff --git a/measureme/src/raw_event.rs b/measureme/src/raw_event.rs
index c9e854a..557ff31 100644
--- a/measureme/src/raw_event.rs
+++ b/measureme/src/raw_event.rs
@@ -1,3 +1,4 @@
+use crate::event_id::EventId;
 use crate::stringtable::StringId;
 
 /// `RawEvent` is how events are stored on-disk. If you change this struct,
@@ -6,7 +7,7 @@ use crate::stringtable::StringId;
 #[repr(C)]
 pub struct RawEvent {
     pub event_kind: StringId,
-    pub event_id: StringId,
+    pub event_id: EventId,
     pub thread_id: u32,
 
     // The following 96 bits store the start and the end timestamp, using
@@ -30,7 +31,7 @@ impl RawEvent {
     #[inline]
     pub fn new_interval(
         event_kind: StringId,
-        event_id: StringId,
+        event_id: EventId,
         thread_id: u32,
         start_nanos: u64,
         end_nanos: u64,
@@ -59,7 +60,7 @@ impl RawEvent {
     #[inline]
     pub fn new_instant(
         event_kind: StringId,
-        event_id: StringId,
+        event_id: EventId,
         thread_id: u32,
         timestamp_ns: u64,
     ) -> RawEvent {
@@ -163,7 +164,7 @@ impl Default for RawEvent {
     fn default() -> Self {
         RawEvent {
             event_kind: StringId::INVALID,
-            event_id: StringId::INVALID,
+            event_id: EventId::INVALID,
             thread_id: 0,
             start_time_lower: 0,
             end_time_lower: 0,
@@ -184,11 +185,11 @@ mod tests {
 
     #[test]
     fn is_instant() {
-        assert!(RawEvent::new_instant(StringId::INVALID, StringId::INVALID, 987, 0,).is_instant());
+        assert!(RawEvent::new_instant(StringId::INVALID, EventId::INVALID, 987, 0,).is_instant());
 
         assert!(RawEvent::new_instant(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             987,
             MAX_INSTANT_TIMESTAMP,
         )
@@ -196,7 +197,7 @@ mod tests {
 
         assert!(!RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             987,
             0,
             MAX_INTERVAL_TIMESTAMP,
@@ -209,7 +210,7 @@ mod tests {
     fn invalid_instant_timestamp() {
         let _ = RawEvent::new_instant(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             123,
             // timestamp too large
             MAX_INSTANT_TIMESTAMP + 1,
@@ -221,7 +222,7 @@ mod tests {
     fn invalid_start_timestamp() {
         let _ = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             123,
             // start timestamp too large
             MAX_INTERVAL_TIMESTAMP + 1,
@@ -234,7 +235,7 @@ mod tests {
     fn invalid_end_timestamp() {
         let _ = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             123,
             0,
             // end timestamp too large
@@ -247,7 +248,7 @@ mod tests {
     fn invalid_end_timestamp2() {
         let _ = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             123,
             0,
             INSTANT_TIMESTAMP_MARKER,
@@ -259,7 +260,7 @@ mod tests {
     fn start_greater_than_end_timestamp() {
         let _ = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             123,
             // start timestamp greater than end timestamp
             1,
@@ -270,7 +271,7 @@ mod tests {
     #[test]
     fn start_equal_to_end_timestamp() {
         // This is allowed, make sure we don't panic
-        let _ = RawEvent::new_interval(StringId::INVALID, StringId::INVALID, 123, 1, 1);
+        let _ = RawEvent::new_interval(StringId::INVALID, EventId::INVALID, 123, 1, 1);
     }
 
     #[test]
@@ -278,7 +279,7 @@ mod tests {
         // Check the upper limits
         let e = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             1234,
             MAX_INTERVAL_TIMESTAMP,
             MAX_INTERVAL_TIMESTAMP,
@@ -288,7 +289,7 @@ mod tests {
         assert_eq!(e.end_nanos(), MAX_INTERVAL_TIMESTAMP);
 
         // Check the lower limits
-        let e = RawEvent::new_interval(StringId::INVALID, StringId::INVALID, 1234, 0, 0);
+        let e = RawEvent::new_interval(StringId::INVALID, EventId::INVALID, 1234, 0, 0);
 
         assert_eq!(e.start_nanos(), 0);
         assert_eq!(e.end_nanos(), 0);
@@ -296,7 +297,7 @@ mod tests {
         // Check that end does not bleed into start
         let e = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             1234,
             0,
             MAX_INTERVAL_TIMESTAMP,
@@ -308,7 +309,7 @@ mod tests {
         // Test some random values
         let e = RawEvent::new_interval(
             StringId::INVALID,
-            StringId::INVALID,
+            EventId::INVALID,
             1234,
             0x1234567890,
             0x1234567890A,
@@ -321,14 +322,14 @@ mod tests {
     #[test]
     fn instant_timestamp_decoding() {
         assert_eq!(
-            RawEvent::new_instant(StringId::INVALID, StringId::INVALID, 987, 0,).start_nanos(),
+            RawEvent::new_instant(StringId::INVALID, EventId::INVALID, 987, 0,).start_nanos(),
             0
         );
 
         assert_eq!(
             RawEvent::new_instant(
                 StringId::INVALID,
-                StringId::INVALID,
+                EventId::INVALID,
                 987,
                 MAX_INSTANT_TIMESTAMP,
             )