Introduce NoOpHandler to simplify LocalHandler

Author: herzogp

lib/src/internal/local_handler.rs

@@ -2,55 +2,40 @@ use std::env;
 use std::fs::File;
 use std::io::{Write, Error};
 
+// use crate::internal::noop_handler::NoOpHandler;
 use crate::internal::{LibHandler};
 
 const LOCAL_OUTPUT: &str = "ANTITHESIS_SDK_LOCAL_OUTPUT";
 
 pub struct LocalHandler {
-    maybe_writer: Option<File>
+    writer: File
 }
 
 impl LocalHandler {
-    pub fn new() -> Self {
-        let filename = match env::var(LOCAL_OUTPUT) {
-            Err(_) => return LocalHandler{ maybe_writer: None },
-            Ok(s) => s
-        };
+    pub fn new() -> Option<Self> {
+        let filename = env::var(LOCAL_OUTPUT).ok()?;
 
         let create_result = File::create(&filename);
-        if let Ok(f) = create_result {
-            // Disabling buffering by setting capacity to 0 for now
-            // Inefficient, but ensures that no buffered bytes are abandoned
-            // for a LocalHandler instance that does not get Drop'ed
-            // Seems like LocalHandler gets bound to a reference with 
-            // a 'static lifetime.
-            LocalHandler{
-                maybe_writer: Some(f)
-            }
+        if let Ok(writer) = create_result {
+            Some(LocalHandler{ writer })
         } else {
-                eprintln!("Unable to write to '{}' - {}", filename.as_str(), create_result.unwrap_err());
-                LocalHandler {
-                    maybe_writer: None
-                }
+            eprintln!("Unable to write to '{}' - {}", filename.as_str(), create_result.unwrap_err());
+            None
         }
     }
 }
 
 impl LibHandler for LocalHandler {
+
     fn output(&self, value: &str) -> Result<(), Error> {
-        match &self.maybe_writer {
-            Some(writer_ref) => {
-                let mut writer_mut = writer_ref;
-                // The compact Display impl (selected using `{}`) of `serde_json::Value` contains no newlines,
-                // hence we are outputing valid JSONL format here.
-                // Using the `{:#}` format specifier may results in extra newlines and indentation.
-                // See https://docs.rs/serde_json/latest/serde_json/enum.Value.html#impl-Display-for-Value.
-                writeln!(writer_mut, "{}", value)?;
-                writer_mut.flush()?;
-                Ok(())
-            },
-            None => Ok(())
-        }
+        // The compact Display impl (selected using `{}`) of `serde_json::Value` contains no newlines,
+        // hence we are outputing valid JSONL format here.
+        // Using the `{:#}` format specifier may results in extra newlines and indentation.
+        // See https://docs.rs/serde_json/latest/serde_json/enum.Value.html#impl-Display-for-Value.
+        let mut writer_mut = & self.writer;
+        writeln!(writer_mut, "{}", value)?;
+        writer_mut.flush()?;
+        Ok(())
     }
 
     fn random(&self) -> u64 {

lib/src/internal/mod.rs

@@ -3,9 +3,11 @@ use rustc_version_runtime::version;
 use serde::Serialize;
 use std::io::{Error};
 use local_handler::LocalHandler;
-use voidstar_handler::{VoidstarHandler};
+use voidstar_handler::VoidstarHandler;
+use noop_handler::NoOpHandler;
 
 mod local_handler;
+mod noop_handler;
 mod voidstar_handler;
 
 #[derive(Serialize, Debug)]
@@ -35,7 +37,11 @@ const SDK_VERSION: &str = "0.1.2";
 pub(crate) static LIB_HANDLER: Lazy<Box<dyn LibHandler + Sync + Send>> = Lazy::new(|| {
     let handler: Box<dyn LibHandler + Sync + Send> = match VoidstarHandler::try_load() {
         Ok(handler) => Box::new(handler),
-        Err(_) => Box::new(LocalHandler::new()),
+        Err(_) => match LocalHandler::new() {
+            Some(h) => Box::new(h),
+            None => Box::new(NoOpHandler::new())
+        }
+
     };
     let s = serde_json::to_string(&sdk_info()).unwrap_or("{}".to_owned());
     let _ = handler.output(s.as_str());

lib/src/internal/noop_handler.rs

@@ -0,0 +1,20 @@
+use crate::internal::{LibHandler};
+use std::io::Error;
+
+pub struct NoOpHandler {}
+
+impl NoOpHandler {
+    pub fn new() -> Self {
+        NoOpHandler{}
+    }
+}
+
+impl LibHandler for NoOpHandler {
+    fn output(&self, _value: &str) -> Result<(), Error> {
+        Ok(())
+    }
+
+    fn random(&self) -> u64 {
+        rand::random::<u64>()
+    }
+}