feat: fix json and csv logging

src/arena.rs

@@ -122,7 +122,7 @@ impl<V> Arena<V> {
         }
 
         self.arbitrageur.init(&signal, admin_provider.clone()).await;
-        self.nonce = 7;
+        self.nonce = 6;
 
         for step in 0..config.steps {
             let id = fetcher.toId(self.pool.clone().into()).call().await.unwrap();

src/engine/inspector.rs

@@ -1,5 +1,5 @@
 use std::fs::OpenOptions;
-
+use std::io::Seek;
 use serde::{Deserialize, Serialize};
 
 /// Trait allowing custom behavior to be defined for logging and inspecting values.
@@ -73,26 +73,32 @@ impl Logger {
 
     /// Append a log message to the appropriate file format.
     fn append_to_file(&self, record: &LogMessage) -> Result<(), Box<dyn std::error::Error>> {
-        let file = OpenOptions::new()
+        let mut file = OpenOptions::new()
             .append(true)
+            .write(true)
             .create(true)
             .open(&self.file_path)?;
-
+    
         match self.format {
             LogFormat::Csv => {
                 let mut writer = csv::Writer::from_writer(file);
                 writer.serialize((record.id, &record.name, &record.data))?;
                 writer.flush()?;
             }
             LogFormat::Json => {
-                let mut records: Vec<LogMessage> =
-                    serde_json::from_reader(&file).unwrap_or_default();
+                let mut records: Vec<LogMessage> = if file.metadata()?.len() > 0 {
+                    serde_json::from_reader(&file)?
+                } else {
+                    Vec::new()
+                };
                 records.push(record.clone());
-                serde_json::to_writer(file, &records)?;
+                file.set_len(0)?;
+                file.seek(std::io::SeekFrom::Start(0))?;
+                serde_json::to_writer_pretty(file, &records)?;
             }
         }
         Ok(())
-    }
+    }    
 }
 
 impl Inspector<LogMessage> for Logger {

src/lib.rs

@@ -189,44 +189,45 @@ mod tests {
         config::Config,
         engine::{
             arbitrageur::{Arbitrageur, DefaultArbitrageur, EmptyArbitrageur},
-            inspector::EmptyInspector,
+            inspector::{EmptyInspector, LogMessage, Logger},
         },
         feed::OrnsteinUhlenbeck,
         strategy::Strategy,
     };
 
     struct StrategyMock;
 
-    impl<V> Strategy<V> for StrategyMock {
+    impl Strategy<LogMessage> for StrategyMock {
         fn init(
             &self,
             _provider: AnvilProvider,
             _signal: Signal,
-            _inspector: &mut Box<dyn Inspector<V>>,
+            _inspector: &mut Box<dyn Inspector<LogMessage>>,
         ) {
         }
         fn process(
             &self,
             _provider: AnvilProvider,
             _signal: Signal,
-            _inspector: &mut Box<dyn Inspector<V>>,
+            inspector: &mut Box<dyn Inspector<LogMessage>>,
         ) {
+            inspector.log(LogMessage::new(String::from("test_key"), String::from("test_value")));
         }
     }
 
     #[tokio::test]
     async fn test_arena() {
         let builder: ArenaBuilder<_> = ArenaBuilder::new();
 
-        let mut arena: Arena<f64> = builder
+        let mut arena: Arena<LogMessage> = builder
             .with_strategy(Box::new(StrategyMock {}))
             .with_fee(4000)
             .with_tick_spacing(2)
             .with_feed(Box::new(OrnsteinUhlenbeck::new(0.1, 0.1, 0.1, 0.1, 0.1)))
-            .with_inspector(Box::new(EmptyInspector {}))
-            .with_arbitrageur(Box::new(DefaultArbitrageur::default()))
+            .with_inspector(Box::new(Logger::new_csv(String::from("test.csv"))))
+            .with_arbitrageur(Box::new(EmptyArbitrageur {}))
             .build();
 
-        arena.run(Config::new(2)).await;
+        arena.run(Config::new(5)).await;
     }
 }