feat: Implement logging for database operations

Author: michaelmior

Cargo.lock

@@ -9,3 +9,7 @@ sqlparser = "0.60.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 uuid = { version = "1.8.0", features = ["v7", "serde"] }
+chrono = { version = "0.4.38", features = ["serde"] }
+
+[dev-dependencies]
+tempfile = "3.10.1"

Cargo.toml

@@ -18,8 +18,8 @@ This stage will implement a simple in-memory version of ArgusDB that will serve
 
 This stage will implement logging of all operations in ArgusDB to allow for fault tolerance.
 
-- [] Define a log file format in specs/logging.md
-- [] Add log entries whenever new documents are inserted
+- [x] Define a log file format in specs/logging.md
+- [x] Add log entries whenever new documents are inserted
 - [] Implement log recovery to read the log on restart and recover from a crash
 - [] Implement log rotation and deletion of old log files
 

ROADMAP.md

@@ -1,3 +1,48 @@
 # Log file format
 
+The log file is a sequence of JSON objects, one per line. Each object represents a single operation that modifies the database state.
+
+## Log entry format
+
+Each log entry is a JSON object with the following fields:
+
+- `ts`: An ISO 8601 timestamp of when the operation occurred.
+- `op`: The type of operation. Can be one of "insert", "update", or "delete".
+- `doc`: The document for "insert" and "update" operations.
+- `id`: The document ID for "update" and "delete" operations.
+
+### Insert operation
+
+```json
+{
+  "ts": "2026-01-10T12:00:00.000Z",
+  "op": "insert",
+  "doc": { "a": 1 }
+}
+```
+
+### Update operation
+
+```json
+{
+  "ts": "2026-01-10T12:00:01.000Z",
+  "op": "update",
+  "id": "01H4J3J4J3J4J3J4J3J4J3J4J3",
+  "doc": { "b": "hello" }
+}
+```
+
+### Delete operation
+
+```json
+{
+  "ts": "2026-01-10T12:00:02.000Z",
+  "op": "delete",
+  "id": "01H4J3J4J3J4J3J4J3J4J3J4J3"
+}
+```
+
 # Log rotation
+
+When the log file reaches a certain size, a new log file is created. The old log file can be archived or deleted.
+The exact mechanism for rotation and archiving is to be determined.

specs/logging.md

@@ -0,0 +1,50 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::Path;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum Operation {
+    Insert {
+        doc: Value,
+    },
+    Update {
+        id: String,
+        doc: Value,
+    },
+    Delete {
+        id: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct LogEntry {
+    pub ts: DateTime<Utc>,
+    pub op: Operation,
+}
+
+pub struct Logger {
+    file: std::fs::File,
+}
+
+impl Logger {
+    pub fn new<P: AsRef<Path>>(path: P) -> std::io::Result<Self> {
+        let file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .append(true)
+            .open(path)?;
+        Ok(Logger { file })
+    }
+
+    pub fn log(&mut self, op: Operation) -> std::io::Result<()> {
+        let entry = LogEntry {
+            ts: Utc::now(),
+            op,
+        };
+        let json = serde_json::to_string(&entry)?;
+        writeln!(self.file, "{}", json)
+    }
+}

src/log.rs

@@ -1,5 +1,6 @@
 pub mod schema;
 pub mod storage;
+pub mod log;
 
 fn main() {
     println!("Hello, world!");

src/main.rs

@@ -1,3 +1,4 @@
+use crate::log::{Logger, Operation};
 use crate::schema::{infer_schema, Schema};
 use serde_json::Value;
 use std::collections::BTreeMap;
@@ -6,36 +7,51 @@ use uuid::Uuid;
 pub struct MemTable {
     documents: BTreeMap<String, Value>,
     schema: Schema,
+    logger: Logger,
 }
 
 impl MemTable {
-    pub fn new() -> Self {
+    pub fn new(log_path: &str) -> Self {
+        let logger = Logger::new(log_path).unwrap();
         MemTable {
             documents: BTreeMap::new(),
             schema: Schema {
                 types: vec![],
                 properties: None,
                 items: None,
             },
+            logger,
         }
     }
 
     pub fn insert(&mut self, doc: Value) -> String {
         let doc_schema = infer_schema(&doc);
-        self.schema.merge(doc_schema);
+        self.schema.merge(doc_schema.clone());
         let id = Uuid::now_v7().to_string();
-        self.documents.insert(id.clone(), doc);
+        self.documents.insert(id.clone(), doc.clone());
+        self.logger
+            .log(Operation::Insert { doc })
+            .expect("Failed to log insert");
         id
     }
 
     pub fn delete(&mut self, id: &str) {
         self.documents.remove(id);
+        self.logger
+            .log(Operation::Delete { id: id.to_string() })
+            .expect("Failed to log delete");
     }
 
     pub fn update(&mut self, id: &str, doc: Value) {
         let doc_schema = infer_schema(&doc);
         self.schema.merge(doc_schema);
-        self.documents.insert(id.to_string(), doc);
+        self.documents.insert(id.to_string(), doc.clone());
+        self.logger
+            .log(Operation::Update {
+                id: id.to_string(),
+                doc,
+            })
+            .expect("Failed to log update");
     }
 }
 
@@ -44,10 +60,17 @@ mod tests {
     use super::*;
     use crate::schema::SchemaType;
     use serde_json::json;
+    use tempfile::NamedTempFile;
+
+    fn create_test_memtable() -> (NamedTempFile, MemTable) {
+        let log_file = NamedTempFile::new().unwrap();
+        let memtable = MemTable::new(log_file.path().to_str().unwrap());
+        (log_file, memtable)
+    }
 
     #[test]
     fn test_memtable_insert() {
-        let mut memtable = MemTable::new();
+        let (_log_file, mut memtable) = create_test_memtable();
         memtable.insert(json!({"a": 1}));
         memtable.insert(json!({"b": "hello"}));
 
@@ -62,7 +85,7 @@ mod tests {
 
     #[test]
     fn test_memtable_delete() {
-        let mut memtable = MemTable::new();
+        let (_log_file, mut memtable) = create_test_memtable();
         let id = memtable.insert(json!({"a": 1}));
         assert_eq!(memtable.documents.len(), 1);
         memtable.delete(&id);
@@ -71,7 +94,7 @@ mod tests {
 
     #[test]
     fn test_memtable_update() {
-        let mut memtable = MemTable::new();
+        let (_log_file, mut memtable) = create_test_memtable();
         let id = memtable.insert(json!({"a": 1}));
         memtable.update(&id, json!({"b": "hello"}));
 
@@ -85,4 +108,40 @@ mod tests {
         assert_eq!(props.get("a").unwrap().types, vec![SchemaType::Integer]);
         assert_eq!(props.get("b").unwrap().types, vec![SchemaType::String]);
     }
+
+    #[test]
+    fn test_log_content() {
+        let (log_file, mut memtable) = create_test_memtable();
+        let doc1 = json!({"a": 1});
+        let id1 = memtable.insert(doc1.clone());
+
+        let doc2 = json!({"b": "hello"});
+        memtable.update(&id1, doc2.clone());
+
+        memtable.delete(&id1);
+
+        let log_content = std::fs::read_to_string(log_file.path()).unwrap();
+        let mut lines = log_content.lines();
+
+        let entry1: crate::log::LogEntry = serde_json::from_str(lines.next().unwrap()).unwrap();
+        match entry1.op {
+            Operation::Insert { doc } => assert_eq!(doc, doc1),
+            _ => panic!("Expected insert operation"),
+        }
+
+        let entry2: crate::log::LogEntry = serde_json::from_str(lines.next().unwrap()).unwrap();
+        match entry2.op {
+            Operation::Update { id, doc } => {
+                assert_eq!(id, id1);
+                assert_eq!(doc, doc2);
+            }
+            _ => panic!("Expected update operation"),
+        }
+
+        let entry3: crate::log::LogEntry = serde_json::from_str(lines.next().unwrap()).unwrap();
+        match entry3.op {
+            Operation::Delete { id } => assert_eq!(id, id1),
+            _ => panic!("Expected delete operation"),
+        }
+    }
 }