Skip to content

Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.

feat: add lightweight lineage module with compressed event log

FABIOTESSbc560613e26f
diff --git a/src/lib.rs b/src/lib.rs
index 7bddeee4..5e6b72b8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,7 @@
pub mod config;
pub mod graph;
pub mod ingest;
+pub mod lineage;
pub mod mapping;
pub mod ontology;
pub mod reason;
diff --git a/src/lineage.rs b/src/lineage.rs
new file mode 100644
index 00000000..4bd4f1e8
--- /dev/null
+++ b/src/lineage.rs
@@ -0,0 +1,71 @@
+use crate::state::StateDb;
+use chrono::Utc;
+
+/// Append-only lineage log. Compressed format for AI consumption.
+pub struct LineageLog {
+ db: StateDb,
+}
+
+impl LineageLog {
+ pub fn new(db: StateDb) -> Self {
+ Self { db }
+ }
+
+ /// Generate a new session ID (short hex).
+ pub fn new_session(&self) -> String {
+ format!("{:08x}", rand_id())
+ }
+
+ /// Record a lineage event.
+ /// Format: session:seq:timestamp:event_type:operation:details
+ pub fn record(&self, session_id: &str, event_type: &str, operation: &str, details: &str) {
+ let conn = self.db.conn();
+ // Get next seq for this session
+ let seq: i64 = conn
+ .query_row(
+ "SELECT COALESCE(MAX(seq), 0) + 1 FROM lineage_events WHERE session_id = ?1",
+ rusqlite::params![session_id],
+ |r| r.get(0),
+ )
+ .unwrap_or(1);
+ let ts = Utc::now().timestamp();
+ let _ = conn.execute(
+ "INSERT INTO lineage_events (session_id, seq, timestamp, event_type, operation, details)
+ VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
+ rusqlite::params![session_id, seq, ts.to_string(), event_type, operation, details],
+ );
+ }
+
+ /// Get compact lineage for a session.
+ /// Returns: "session:seq:timestamp:type:operation:details\n" per event.
+ pub fn get_compact(&self, session_id: &str) -> String {
+ let conn = self.db.conn();
+ let mut stmt = conn
+ .prepare(
+ "SELECT seq, timestamp, event_type, operation, details
+ FROM lineage_events WHERE session_id = ?1 ORDER BY seq ASC",
+ )
+ .unwrap();
+ let rows: Vec<String> = stmt
+ .query_map(rusqlite::params![session_id], |row| {
+ let seq: i64 = row.get(0)?;
+ let ts: String = row.get(1)?;
+ let etype: String = row.get(2)?;
+ let op: String = row.get(3)?;
+ let details: String = row.get::<_, Option<String>>(4)?.unwrap_or_default();
+ Ok(format!("{}:{}:{}:{}:{}:{}", session_id, seq, ts, etype, op, details))
+ })
+ .unwrap()
+ .filter_map(|r| r.ok())
+ .collect();
+ rows.join("\n") + "\n"
+ }
+}
+
+fn rand_id() -> u32 {
+ use std::time::SystemTime;
+ let d = SystemTime::now()
+ .duration_since(SystemTime::UNIX_EPOCH)
+ .unwrap();
+ (d.as_nanos() & 0xFFFF_FFFF) as u32
+}
diff --git a/tests/lineage_test.rs b/tests/lineage_test.rs
new file mode 100644
index 00000000..cdba8808
--- /dev/null
+++ b/tests/lineage_test.rs
@@ -0,0 +1,60 @@
+use open_ontologies::lineage::LineageLog;
+use open_ontologies::state::StateDb;
+use tempfile::NamedTempFile;
+
+#[test]
+fn test_lineage_record_and_query() {
+ let tmp = NamedTempFile::new().unwrap();
+ let db = StateDb::open(tmp.path()).unwrap();
+ let log = LineageLog::new(db.clone());
+
+ let session = log.new_session();
+ log.record(&session, "L", "load", "0→847");
+ log.record(&session, "R", "reason", "owl-dl:847→1203");
+ log.record(&session, "M", "monitor", "ok");
+
+ let events = log.get_compact(&session);
+ let lines: Vec<&str> = events.trim().lines().collect();
+ assert_eq!(lines.len(), 3);
+ assert!(lines[0].contains(":L:load:0→847"));
+ assert!(lines[1].contains(":R:reason:owl-dl:847→1203"));
+ assert!(lines[2].contains(":M:monitor:ok"));
+}
+
+#[test]
+fn test_lineage_session_isolation() {
+ let tmp = NamedTempFile::new().unwrap();
+ let db = StateDb::open(tmp.path()).unwrap();
+ let log = LineageLog::new(db.clone());
+
+ let s1 = log.new_session();
+ let s2 = log.new_session();
+ log.record(&s1, "L", "load", "100");
+ log.record(&s2, "L", "load", "200");
+
+ let e1 = log.get_compact(&s1);
+ let e2 = log.get_compact(&s2);
+ assert!(e1.contains("100"));
+ assert!(!e1.contains("200"));
+ assert!(e2.contains("200"));
+ assert!(!e2.contains("100"));
+}
+
+#[test]
+fn test_lineage_sequential_numbering() {
+ let tmp = NamedTempFile::new().unwrap();
+ let db = StateDb::open(tmp.path()).unwrap();
+ let log = LineageLog::new(db.clone());
+
+ let session = log.new_session();
+ log.record(&session, "L", "load", "a");
+ log.record(&session, "V", "validate", "b");
+ log.record(&session, "R", "reason", "c");
+
+ let events = log.get_compact(&session);
+ let lines: Vec<&str> = events.trim().lines().collect();
+ // seq numbers should be 1, 2, 3
+ assert!(lines[0].starts_with(&format!("{}:1:", session)));
+ assert!(lines[1].starts_with(&format!("{}:2:", session)));
+ assert!(lines[2].starts_with(&format!("{}:3:", session)));
+}