feat: make log a separate event

Author: michael-0acf4

.vscode/settings.json

@@ -29,6 +29,7 @@
   "rust-analyzer.cargo.allTargets": true,
   "rust-analyzer.check.features": "all",
   "rust-analyzer.check.allTargets": true,
+  "rust-analyzer.cachePriming.enable": false,
   "editor.wordWrap": "on",
   "[python]": {
     "editor.defaultFormatter": "ms-python.black-formatter",
@@ -38,7 +39,7 @@
     }
   },
   "[typescript]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
+    "editor.defaultFormatter": "denoland.vscode-deno"
   },
   "languageToolLinter.languageTool.ignoredWordsInWorkspace": [
     "cockroachdb",

src/substantial/protocol/events.proto

@@ -31,6 +31,12 @@ message Save {
   }
 }
 
+message Log {
+  uint32 id = 1;
+  string json_payload = 2;
+  uint32 level = 3;
+}
+
 message Sleep {
   uint32 id = 1;
   google.protobuf.Timestamp start = 2;
@@ -57,6 +63,7 @@ message Event {
     Sleep sleep = 12;
     Send send = 13;
     Stop stop = 14;
+    Log log = 15;
   }
 };
 

src/substantial/src/converters.rs

@@ -44,7 +44,15 @@ pub enum SavedValue {
     },
 }
 
-/// Bridge between protobuf types to Typescript
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(tag = "type")]
+pub enum LogLevel {
+    Warn,
+    Info,
+    Error,
+}
+
+/// Bridge between protobuf types and Typescript
 #[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(tag = "type")]
 pub enum OperationEvent {
@@ -67,6 +75,11 @@ pub enum OperationEvent {
     Start {
         kwargs: HashMap<String, serde_json::Value>,
     },
+    Log {
+        id: u32,
+        payload: serde_json::Value,
+        level: LogLevel,
+    },
     Compensate,
 }
 
@@ -257,10 +270,20 @@ impl TryFrom<Event> for Operation {
                         },
                     });
                 }
+                Of::Log(log) => {
+                    return Ok(Operation {
+                        at,
+                        event: OperationEvent::Log {
+                            id: log.id,
+                            payload: serde_json::from_str(&log.json_payload)?,
+                            level: log.level.try_into()?,
+                        },
+                    })
+                }
             }
         }
 
-        bail!("cannot convert from event {:?}", event)
+        bail!("Fatal: cannot convert from event {:?}", event)
     }
 }
 
@@ -269,7 +292,7 @@ impl TryFrom<Operation> for Event {
     fn try_from(operation: Operation) -> Result<Event> {
         use crate::protocol::events::event::Of;
         use crate::protocol::events::save::Of::{Failed, Resolved, Retry};
-        use crate::protocol::events::{stop, Event, Save, Send, Sleep, Start, Stop};
+        use crate::protocol::events::{stop, Event, Log, Save, Send, Sleep, Start, Stop};
 
         let at = to_timestamp(&operation.at);
 
@@ -377,6 +400,20 @@ impl TryFrom<Operation> for Event {
                     ..Default::default()
                 })
             }
+            OperationEvent::Log { id, payload, level } => {
+                let log = Log {
+                    id,
+                    json_payload: serde_json::to_string(&payload)?,
+                    level: level.into(),
+                    ..Default::default()
+                };
+
+                Ok(Event {
+                    at: MessageField::some(at),
+                    of: Some(Of::Log(log)),
+                    ..Default::default()
+                })
+            }
             OperationEvent::Compensate => {
                 unimplemented!()
             }
@@ -444,6 +481,28 @@ impl TryFrom<MetadataEvent> for Metadata {
     }
 }
 
+impl From<LogLevel> for u32 {
+    fn from(value: LogLevel) -> Self {
+        match value {
+            LogLevel::Info => 0,
+            LogLevel::Warn => 5,
+            LogLevel::Error => 10,
+        }
+    }
+}
+
+impl TryFrom<u32> for LogLevel {
+    type Error = anyhow::Error;
+    fn try_from(value: u32) -> anyhow::Result<Self> {
+        Ok(match value {
+            0 => LogLevel::Info,
+            5 => LogLevel::Warn,
+            10 => LogLevel::Error,
+            _ => anyhow::bail!("Unknown log level {value:?}"),
+        })
+    }
+}
+
 fn to_timestamp(datetime: &DateTime<Utc>) -> Timestamp {
     let mut timestamp = Timestamp::new();
     timestamp.seconds = datetime.timestamp();