logging to file (experimental)

.env.example

@@ -1,2 +1,3 @@
 RPC_URL_WS=ws://127.0.0.1:8545
 DB_URL=mongodb://localhost:27017
+LOG_TO_FILE=false

.gitignore

@@ -2,4 +2,5 @@
 target
 *.json
 arbData
+logs
 

Cargo.toml

@@ -21,5 +21,6 @@ serde = "1.0.164"
 serde_json = {version = "1.0.99", features = ["arbitrary_precision", "std", "preserve_order"]}
 tokio = {version = "1.29.1", features = ["macros", "net", "process", "rt", "rt-multi-thread", "sync", "time"]}
 tracing = "0.1.37"
-tracing-subscriber = "0.3.17"
+tracing-appender = "0.2.2"
+tracing-subscriber = { version = "0.3.17", features = ["env-filter", "fmt", "json", "tracing-log", "tracing"] }
 uniswap_v3_math = {git = "https://github.com/0xKitsune/uniswap_v3_math.git"}

src/commands/scan.rs

@@ -1,8 +1,8 @@
 use crate::config::Config;
 use crate::data::arbs::ArbDb;
 use crate::event_history::event_history_url;
-use crate::hindsight::Hindsight;
 use crate::info;
+use crate::processor::Processor;
 use crate::sim::processor::H256Map;
 use crate::util::{fetch_txs, filter_events_by_topic, get_ws_client};
 use crate::Result;
@@ -56,7 +56,7 @@ pub async fn run(params: ScanOptions, config: Config) -> Result<()> {
     );
     let ws_client = get_ws_client(None).await?;
     let mevshare = EventClient::default();
-    let hindsight = Hindsight::new(config.rpc_url_ws).await?;
+    let hindsight = Processor::new(config.rpc_url_ws).await?;
     let db = ArbDb::new(None).await?;
 
     let mut event_params: EventHistoryParams = params.clone().into();

src/config.rs

@@ -5,11 +5,16 @@ use std::env;
 pub struct Config {
     pub rpc_url_ws: String,
     pub db_url: String,
+    pub log_to_file: bool,
 }
 
 impl Config {
-    pub fn new(rpc_url_ws: String, db_url: String) -> Config {
-        Config { rpc_url_ws, db_url }
+    pub fn new(rpc_url_ws: String, db_url: String, log_to_file: bool) -> Config {
+        Config {
+            rpc_url_ws,
+            db_url,
+            log_to_file,
+        }
     }
 }
 
@@ -23,6 +28,9 @@ impl Default for Config {
         Config {
             db_url: env::var("DB_URL").expect("DB_URL must be set"),
             rpc_url_ws: env::var("RPC_URL_WS").expect("RPC_URL_WS must be set"),
+            log_to_file: env::var("LOG_TO_FILE")
+                .map(|v| v.to_string() == "true")
+                .unwrap_or(false),
         }
     }
 }

src/lib.rs

@@ -3,8 +3,9 @@ pub mod config;
 pub mod data;
 pub mod error;
 pub mod event_history;
-pub mod hindsight;
 pub mod interfaces;
+pub mod logs;
+pub mod processor;
 pub mod sim;
 pub mod util;
 

src/logs.rs

@@ -0,0 +1,24 @@
+use tracing_appender::rolling::RollingFileAppender;
+
+fn get_file_appender() -> RollingFileAppender {
+    // tracing_appender::rolling::hourly("./logs", "trace.log")
+    tracing_appender::rolling::minutely("./logs", "trace.log")
+}
+
+pub struct FileLogger {
+    _guard: Box<tracing_appender::non_blocking::WorkerGuard>,
+}
+
+impl FileLogger {
+    pub fn new() -> Self {
+        let (non_blocking, guard) = tracing_appender::non_blocking(get_file_appender());
+        tracing_subscriber::fmt()
+            .with_writer(std::io::stderr)
+            .with_writer(std::io::stdout)
+            .with_writer(non_blocking)
+            .init();
+        Self {
+            _guard: Box::new(guard),
+        }
+    }
+}

src/main.rs

@@ -5,6 +5,7 @@ use hindsight::{
     config::Config,
     data::arbs::ArbFilterParams,
     debug, info,
+    logs::FileLogger,
 };
 use revm::primitives::bitvec::macros::internal::funty::Fundamental;
 
@@ -63,8 +64,21 @@ enum Commands {
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    tracing_subscriber::fmt::init();
+    //
+    // let file_appender = get_file_appender();
+    // let (non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
+    // tracing_subscriber::fmt().with_writer(non_blocking).init();
+
+    // let (non_blocking, _guard) =
+    //     tracing_appender::non_blocking(tracing_appender::rolling::minutely("./logs", "trace.log"));
     let config = Config::default();
+    let _f = if config.log_to_file {
+        println!("check `./logs/` for logs");
+        Some(FileLogger::new())
+    } else {
+        tracing_subscriber::fmt().init();
+        None
+    };
     let cli = Cli::parse();
 
     match cli.command {

src/hindsight.rs → src/processor.rs

@@ -10,11 +10,11 @@ use futures::future;
 use mev_share_sse::EventHistory;
 
 #[derive(Clone, Debug)]
-pub struct Hindsight {
+pub struct Processor {
     pub client: WsClient,
 }
 
-impl Hindsight {
+impl Processor {
     pub async fn new(rpc_url_ws: String) -> Result<Self> {
         let client = get_ws_client(Some(rpc_url_ws)).await?;
         Ok(Self { client })
@@ -81,7 +81,7 @@ mod tests {
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn it_processes_orderflow() -> Result<()> {
         let config = Config::default();
-        let hindsight = Hindsight::new(config.rpc_url_ws).await?;
+        let hindsight = Processor::new(config.rpc_url_ws).await?;
 
         // data from an actual juicy event
         let juicy_event: EventHistory = serde_json::from_value(json!({