Merge pull request #32 from Shopify/error-propagation

feat: structured error logging / propagation

Author: hainsdominic

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "function-runner"
-version = "3.0.0"
+version = "3.1.0"
 edition = "2021"
 
 [profile.test]

Cargo.toml

@@ -5,7 +5,10 @@ use std::{
 };
 use wasmtime::{Config, Engine, Linker, Module, Store};
 
-use crate::function_run_result::FunctionRunResult;
+use crate::function_run_result::{
+    FunctionOutput::{self, InvalidJsonOutput, JsonOutput},
+    FunctionRunResult, InvalidOutput,
+};
 
 const KB_PER_PAGE: u64 = 64;
 
@@ -32,6 +35,7 @@ pub fn run(function_path: PathBuf, input_path: PathBuf) -> Result<FunctionRunRes
 
     let runtime: Duration;
     let memory_usage: u64;
+    let mut error_logs: String = String::new();
 
     {
         let mut linker = Linker::new(&engine);
@@ -76,24 +80,35 @@ pub fn run(function_path: PathBuf, input_path: PathBuf) -> Result<FunctionRunRes
         match module_result {
             Ok(_) => {}
             Err(e) => {
-                eprintln!("Error:\n{}", e);
+                error_logs = e.to_string();
             }
         }
     };
 
-    let logs = error_stream
+    let raw_logs = error_stream
         .try_into_inner()
         .expect("Error stream reference still exists")
         .into_inner();
-    let logs =
-        std::str::from_utf8(&logs).map_err(|e| anyhow!("Couldn't print Function Logs: {}", e))?;
+    let mut logs = std::string::String::from_utf8(raw_logs)
+        .map_err(|e| anyhow!("Couldn't print Function Logs: {}", e))?;
+
+    logs.push_str(&error_logs);
 
-    let output = output_stream
+    let raw_output = output_stream
         .try_into_inner()
         .expect("Output stream reference still exists")
         .into_inner();
-    let output: serde_json::Value = serde_json::from_slice(output.as_slice())
-        .map_err(|e| anyhow!("Couldn't decode Function Output: {}", e))?;
+
+    let output: FunctionOutput = match serde_json::from_slice(&raw_output) {
+        Ok(json_output) => JsonOutput(json_output),
+        Err(error) => InvalidJsonOutput(InvalidOutput {
+            stdout: std::str::from_utf8(&raw_output)
+                .map_err(|e| anyhow!("Couldn't print Function Output: {}", e))
+                .unwrap()
+                .to_owned(),
+            error: error.to_string(),
+        }),
+    };
 
     let name = function_path.file_name().unwrap().to_str().unwrap();
     let size = function_path.metadata()?.len();
@@ -103,8 +118,8 @@ pub fn run(function_path: PathBuf, input_path: PathBuf) -> Result<FunctionRunRes
         runtime,
         size,
         memory_usage,
-        output,
         logs.to_string(),
+        output,
     );
 
     Ok(function_run_result)
@@ -149,9 +164,12 @@ mod tests {
         let function_run_result = run(
             Path::new("tests/benchmarks/stack_overflow.wasm").to_path_buf(),
             Path::new("tests/benchmarks/stack_overflow.json").to_path_buf(),
-        );
+        )
+        .unwrap();
 
-        assert!(function_run_result.is_err());
+        assert!(function_run_result
+            .logs
+            .contains("out of bounds memory access"));
     }
 
     #[test]

src/engine.rs

@@ -1,15 +1,27 @@
 use colored::Colorize;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::{fmt, time::Duration};
 
+#[derive(Serialize, Deserialize)]
+pub struct InvalidOutput {
+    pub error: String,
+    pub stdout: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub enum FunctionOutput {
+    JsonOutput(serde_json::Value),
+    InvalidJsonOutput(InvalidOutput),
+}
+
 #[derive(Serialize)]
 pub struct FunctionRunResult {
     pub name: String,
     pub runtime: Duration,
     pub size: u64,
     pub memory_usage: u64,
     pub logs: String,
-    pub output: serde_json::Value,
+    pub output: FunctionOutput,
 }
 
 impl FunctionRunResult {
@@ -18,8 +30,8 @@ impl FunctionRunResult {
         runtime: Duration,
         size: u64,
         memory_usage: u64,
-        output: serde_json::Value,
         logs: String,
+        output: FunctionOutput,
     ) -> Self {
         FunctionRunResult {
             name,
@@ -37,26 +49,49 @@ impl FunctionRunResult {
 }
 
 impl fmt::Display for FunctionRunResult {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let title = "      Benchmark Results      ".black().on_bright_green();
-        write!(f, "{}\n\n", title)?;
-        writeln!(f, "Name: {}", self.name)?;
-        writeln!(f, "Runtime: {:?}", self.runtime)?;
-        writeln!(f, "Memory Usage: {}KB", self.memory_usage)?;
-        writeln!(f, "Size: {}KB\n", self.size / 1024)?;
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        let title = "      Benchmark Results      "
+            .black()
+            .on_truecolor(150, 191, 72);
+        write!(formatter, "{}\n\n", title)?;
+        writeln!(formatter, "Name: {}", self.name)?;
+        writeln!(formatter, "Runtime: {:?}", self.runtime)?;
+        writeln!(formatter, "Memory Usage: {}KB", self.memory_usage * 64)?;
+        writeln!(formatter, "Size: {}KB\n", self.size / 1024)?;
 
         writeln!(
-            f,
+            formatter,
             "{}\n\n{}",
-            "            Logs             ".black().on_bright_blue(),
+            "            Logs            ".black().on_bright_blue(),
             self.logs
         )?;
 
-        writeln!(
-            f,
-            "Output:\n{}",
-            serde_json::to_string_pretty(&self.output).unwrap_or_else(|error| error.to_string())
-        )?;
+        match &self.output {
+            FunctionOutput::JsonOutput(json_output) => {
+                writeln!(
+                    formatter,
+                    "{}\n\n{}",
+                    "           Output           ".black().on_bright_green(),
+                    serde_json::to_string_pretty(&json_output)
+                        .unwrap_or_else(|error| error.to_string())
+                )?;
+            }
+            FunctionOutput::InvalidJsonOutput(invalid_output) => {
+                writeln!(
+                    formatter,
+                    "{}\n\n{}",
+                    "        Invalid Output      ".black().on_bright_red(),
+                    invalid_output.stdout
+                )?;
+
+                writeln!(
+                    formatter,
+                    "{}\n\n{}",
+                    "         JSON Error         ".black().on_bright_red(),
+                    invalid_output.error
+                )?;
+            }
+        }
 
         Ok(())
     }