feat: add tracer to help with generating traces

Author: alehander92

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "trace_types"
-version = "0.4.2"
+version = "0.5.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 150

src/lib.rs

@@ -1,3 +1,34 @@
+use std::path::PathBuf;
+mod tracer;
 mod types;
+pub use crate::tracer::{Tracer, NONE_TYPE_ID, NONE_VALUE};
 pub use crate::types::*;
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simple_trace() {
+        let mut tracer = Tracer::new("path.small", &vec![]);
+        let path = PathBuf::from("/test/path.small");
+        tracer.start(&path, Line(1));
+        tracer.register_step(&path, Line(1));
+        tracer.register_step(&path, Line(2));
+        tracer.register_special_event(EventLogKind::Write, "test");
+        tracer.register_special_event(EventLogKind::Write, "test2");
+        let function_id = tracer.ensure_function_id("function", &path, Line(3));
+        tracer.register_call(function_id, vec![]);
+
+        let int_value = ValueRecord::Int {
+            i: 1,
+            type_id: tracer.ensure_type_id(TypeKind::Int, "Int")
+        };
+        tracer.register_variable_with_full_value("test_variable", int_value);
+        tracer.register_return(NONE_VALUE);
+        assert_eq!(tracer.events.len(), 14);
+        // visible with
+        // cargo tets -- --nocapture
+        println!("{:#?}", tracer.events);
+    }
+}

src/tracer.rs

@@ -0,0 +1,155 @@
+use crate::types::{
+    ArgRecord, CallRecord, EventLogKind, FullValueRecord, FunctionId, FunctionRecord, Line, PathId, RecordEvent, ReturnRecord, StepRecord,
+    TraceLowLevelEvent, TypeId, ValueRecord, VariableId, TypeSpecificInfo, TypeRecord, TypeKind,
+};
+use std::collections::HashMap;
+use std::env;
+use std::path::{Path, PathBuf};
+
+pub struct Tracer {
+    // trace metadata:
+    workdir: PathBuf,
+    program: String,
+    args: Vec<String>,
+    // trace events
+    pub events: Vec<TraceLowLevelEvent>,
+
+    // internal tracer state:
+    paths: HashMap<PathBuf, PathId>,
+    functions: HashMap<String, FunctionId>,
+    variables: HashMap<String, VariableId>,
+    types: HashMap<String, TypeId>,
+}
+
+// we ensure in start they are registered with those id-s
+
+// pub const EXAMPLE_INT_TYPE_ID: TypeId = TypeId(0);
+// pub const EXAMPLE_FLOAT_TYPE_ID: TypeId = TypeId(1);
+// pub const EXAMPLE_BOOL_TYPE_ID: TypeId = TypeId(2);
+// pub const EXAMPLE_STRING_TYPE_ID: TypeId = TypeId(3);
+pub const NONE_TYPE_ID: TypeId = TypeId(0);
+pub const NONE_VALUE: ValueRecord = ValueRecord::None { type_id: NONE_TYPE_ID };
+
+impl Tracer {
+    pub fn new(program: &str, args: &[String]) -> Self {
+        Tracer {
+            workdir: env::current_dir().unwrap(),
+            program: program.to_string(),
+            args: args.to_vec(),
+            events: vec![],
+
+            paths: HashMap::new(),
+            functions: HashMap::new(),
+            variables: HashMap::new(),
+            types: HashMap::new(),
+        }
+    }
+
+    pub fn start(&mut self, path: &PathBuf, line: Line) {
+        let path_id = self.ensure_path_id(path);
+        let function_id = self.ensure_function_id("<toplevel>", path, line);
+        self.register_call(function_id, vec![]);
+
+        // probably we let the user choose, as different languages have
+        // different base types/names
+        // assert!(EXAMPLE_INT_TYPE_ID == self.load_type_id(TypeKind::Int, "Int"));
+        // assert!(EXAMPLE_FLOAT_TYPE_ID == self.load_type_id(TypeKind::Float, "Float"));
+        // assert!(EXAMPLE_BOOL_TYPE_ID == self.load_type_id(TypeKind::Bool, "Bool"));
+        // assert!(EXAMPLE_STRING_TYPE_ID == self.load_type_id(TypeKind::Bool, "String"));
+        assert!(NONE_TYPE_ID == self.ensure_type_id(TypeKind::None, "None"));
+    }
+
+    pub fn ensure_path_id(&mut self, path: &Path) -> PathId {
+        if !self.paths.contains_key(path) {
+            self.paths.insert(path.to_path_buf(), PathId(self.paths.len()));
+            self.register_path(path);
+        }
+        *self.paths.get(path).unwrap()
+    }
+
+    pub fn ensure_function_id(&mut self, function_name: &str, path: &Path, line: Line) -> FunctionId {
+        if !self.functions.contains_key(function_name) {
+            // same function names for different path line? TODO
+            self.functions.insert(function_name.to_string(), FunctionId(self.functions.len()));
+            self.register_function(function_name, path, line);
+        }
+        *self.functions.get(function_name).unwrap()
+    }
+
+    pub fn ensure_type_id(&mut self, kind: TypeKind, lang_type: &str) -> TypeId {
+        if !self.types.contains_key(lang_type) {
+            self.types.insert(lang_type.to_string(), TypeId(self.types.len()));
+            self.register_type(kind, lang_type);
+        }
+        *self.types.get(lang_type).unwrap()
+    }
+
+    pub fn ensure_variable_id(&mut self, variable_name: &str) -> VariableId {
+        if !self.variables.contains_key(variable_name) {
+            self.variables.insert(variable_name.to_string(), VariableId(self.variables.len()));
+            self.register_variable_event(variable_name);
+        }
+        *self.variables.get(variable_name).unwrap()
+    }
+
+    pub fn register_path(&mut self, path: &Path) {
+        self.events.push(TraceLowLevelEvent::Path(path.to_path_buf()));
+    }
+
+    pub fn register_function(&mut self, name: &str, path: &Path, line: Line) {
+        let path_id = self.ensure_path_id(path);
+        self.events.push(TraceLowLevelEvent::Function(FunctionRecord {
+            name: name.to_string(),
+            path_id,
+            line,
+        }));
+    }
+
+    pub fn register_step(&mut self, path: &PathBuf, line: Line) {
+        let path_id = self.ensure_path_id(path);
+        self.events.push(TraceLowLevelEvent::Step(StepRecord { path_id, line: line }));
+    }
+
+    pub fn register_call(&mut self, function_id: FunctionId, args: Vec<ArgRecord>) {
+        self.events.push(TraceLowLevelEvent::Call(CallRecord { function_id, args }));
+    }
+
+    pub fn register_return(&mut self, return_value: ValueRecord) {
+        self.events.push(TraceLowLevelEvent::Return(ReturnRecord { return_value }));
+    }
+
+    pub fn register_special_event(&mut self, kind: EventLogKind, content: &str) {
+        self.events.push(TraceLowLevelEvent::Event(RecordEvent {
+            kind,
+            content: content.to_string(),
+        }));
+    }
+
+    pub fn register_type(&mut self, kind: TypeKind, lang_type: &str) {
+        let typ = TypeRecord {
+            kind,
+            lang_type: lang_type.to_string(),
+            specific_info: TypeSpecificInfo::None,
+        };
+        self.events.push(TraceLowLevelEvent::Type(typ));
+    }
+
+    pub fn register_variable_with_full_value(&mut self, name: &str, value: ValueRecord) {
+        let variable_id = self.ensure_variable_id(name);
+        self.register_full_value(variable_id, value);
+    }
+
+    pub fn register_variable_event(&mut self, variable_name: &str) {
+        self.events.push(TraceLowLevelEvent::Variable(variable_name.to_string()));
+    }
+
+    pub fn register_full_value(&mut self, variable_id: VariableId, value: ValueRecord) {
+        self.events.push(
+            TraceLowLevelEvent::Value(FullValueRecord {
+                variable_id,
+                value,
+            })
+        );
+    }
+
+}

src/types.rs

@@ -9,10 +9,10 @@ use serde_repr::*;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum TraceLowLevelEvent {
     Step(StepRecord),
-    Path(PathBuf), // should be always generated before usage, so we can stop stream at random n
-    Variable(String), // interning new name for it
-    Type(TypeRecord), // should be always generated before Value referencing it
-    Value(FullValueRecord), // full values: simpler case working even without modification support
+    Path(PathBuf),            // should be always generated before usage, so we can stop stream at random n
+    Variable(String),         // interning new name for it
+    Type(TypeRecord),         // should be always generated before Value referencing it
+    Value(FullValueRecord),   // full values: simpler case working even without modification support
     Function(FunctionRecord), // should be always generated before CallRecord referencing it
     Call(CallRecord),
     Return(ReturnRecord),
@@ -81,9 +81,7 @@ impl Line {
     }
 }
 
-#[derive(
-    Hash, Debug, Default, Copy, Clone, Serialize, Deserialize, Ord, PartialOrd, Eq, PartialEq,
-)]
+#[derive(Hash, Debug, Default, Copy, Clone, Serialize, Deserialize, Ord, PartialOrd, Eq, PartialEq)]
 #[serde(transparent)]
 pub struct PathId(pub usize);
 
@@ -119,7 +117,6 @@ pub struct VariableId(pub usize);
 #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
 pub struct FunctionId(pub usize);
 
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct CallRecord {
     // pub key: CallKey,
@@ -140,7 +137,6 @@ pub struct FunctionRecord {
     pub name: String,
 }
 
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ArgRecord {
     pub name: String,
@@ -233,11 +229,7 @@ pub enum ValueRecord {
     },
 }
 
-
-
-#[derive(
-    Debug, Default, Copy, Clone, FromPrimitive, Serialize_repr, Deserialize_repr, PartialEq,
-)]
+#[derive(Debug, Default, Copy, Clone, FromPrimitive, Serialize_repr, Deserialize_repr, PartialEq)]
 #[repr(u8)]
 pub enum TypeKind {
     #[default]
@@ -295,9 +287,7 @@ pub enum TypeKind {
     Slice,
 }
 
-#[derive(
-    Debug, Default, Copy, Clone, FromPrimitive, Serialize_repr, Deserialize_repr, PartialEq,
-)]
+#[derive(Debug, Default, Copy, Clone, FromPrimitive, Serialize_repr, Deserialize_repr, PartialEq)]
 #[repr(u8)]
 pub enum EventLogKind {
     #[default]
@@ -333,4 +323,3 @@ pub enum EventLogKind {
 
 //     events: Vec<TraceLowLevelEvent>,
 // }
-