[rust]: config flowy log

rust-lib/flowy-document/src/services/doc/document/document.rs

@@ -68,7 +68,7 @@ impl Document {
     }
 
     pub fn compose_delta(&mut self, delta: &Delta) -> Result<(), DocError> {
-        log::trace!("😁 {} compose {}", &self.delta.to_json(), delta.to_json());
+        log::trace!("{} compose {}", &self.delta.to_json(), delta.to_json());
         let composed_delta = self.delta.compose(delta)?;
         let mut undo_delta = delta.invert(&self.delta);
 
@@ -89,7 +89,7 @@ impl Document {
             self.history.record(undo_delta);
         }
 
-        log::trace!("😁😁 compose result: {}", composed_delta.to_json());
+        log::trace!("compose result: {}", composed_delta.to_json());
         self.set_delta(composed_delta);
         Ok(())
     }

rust-lib/flowy-log/Cargo.toml

@@ -18,6 +18,7 @@ log = "0.4.14"
 serde_json = "1.0"
 serde = "1.0"
 chrono = "0.4"
+lazy_static = "1.4.0"
 
 [features]
 use_bunyan = []

rust-lib/flowy-log/src/lib.rs

@@ -5,13 +5,26 @@ use std::path::Path;
 use tracing::subscriber::set_global_default;
 
 use crate::layer::*;
+use lazy_static::lazy_static;
+use std::sync::RwLock;
+use tracing_appender::{non_blocking::WorkerGuard, rolling::RollingFileAppender};
 use tracing_bunyan_formatter::JsonStorageLayer;
 use tracing_log::LogTracer;
-use tracing_subscriber::{layer::SubscriberExt, EnvFilter};
+use tracing_subscriber::{
+    field::MakeExt,
+    fmt::{format, format::FmtSpan},
+    layer::SubscriberExt,
+    EnvFilter,
+};
+
+lazy_static! {
+    static ref LOG_GUARD: RwLock<Option<WorkerGuard>> = RwLock::new(None);
+}
 
 pub struct Builder {
     name: String,
     env_filter: String,
+    file_appender: Option<RollingFileAppender>,
 }
 
 impl Builder {
@@ -19,6 +32,7 @@ impl Builder {
         Builder {
             name: name.to_owned(),
             env_filter: "Info".to_owned(),
+            file_appender: None,
         }
     }
 
@@ -27,29 +41,41 @@ impl Builder {
         self
     }
 
-    pub fn local(self, directory: impl AsRef<Path>) -> Self {
+    pub fn local(mut self, directory: impl AsRef<Path>) -> Self {
         let directory = directory.as_ref().to_str().unwrap().to_owned();
         let local_file_name = format!("{}.log", &self.name);
-        let file_appender = tracing_appender::rolling::daily(directory, local_file_name);
-        let (_non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
+        self.file_appender = Some(tracing_appender::rolling::hourly(directory, local_file_name));
 
         self
     }
 
     pub fn build(self) -> std::result::Result<(), String> {
         let env_filter = EnvFilter::new(self.env_filter);
+        let file_appender = self.file_appender.unwrap();
+        let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
+        let formatting_layer = FlowyFormattingLayer::new(std::io::stdout);
+
+        let formatter =
+            // Construct a custom formatter for `Debug` fields
+            format::debug_fn(|writer, field, value| write!(writer, "{}: {:?}", field, value))
+                // Use the `tracing_subscriber::MakeFmtExt` trait to wrap the
+                // formatter so that a delimiter is added between fields.
+                .delimited(", ");
 
         let subscriber = tracing_subscriber::fmt()
             // .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
+            // .without_time()
+            .with_ansi(false)
             .with_target(false)
             .with_max_level(tracing::Level::TRACE)
             .with_writer(std::io::stderr)
-            .with_thread_ids(true)
-            // .with_writer(non_blocking)
-            // .json()
+            .fmt_fields(formatter)
+            // .with_thread_ids(true)
+            .with_writer(non_blocking)
+            .json()
             .compact()
             .finish()
-            .with(env_filter);
+            .with(env_filter).with(JsonStorageLayer).with(formatting_layer);
 
         // if cfg!(feature = "use_bunyan") {
         //     let formatting_layer = BunyanFormattingLayer::new(self.name.clone(),
@@ -59,16 +85,14 @@ impl Builder {
         //     let _ = set_global_default(subscriber).map_err(|e| format!("{:?}", e))?;
         // }
 
-        let formatting_layer = FlowyFormattingLayer::new(std::io::stdout);
-        let _ = set_global_default(subscriber.with(JsonStorageLayer).with(formatting_layer))
-            .map_err(|e| format!("{:?}", e))?;
-
+        let _ = set_global_default(subscriber).map_err(|e| format!("{:?}", e))?;
         let _ = LogTracer::builder()
             .with_max_level(LevelFilter::Trace)
             .init()
             .map_err(|e| format!("{:?}", e))
             .unwrap();
 
+        *LOG_GUARD.write().unwrap() = Some(guard);
         Ok(())
     }
 }
@@ -86,17 +110,44 @@ mod tests {
     // run  cargo test --features="use_bunyan" or  cargo test
     #[test]
     fn test_log() {
-        let _ = Builder::new("flowy").env_filter("debug").build();
-        tracing::info!("😁 Tracing info log");
-
-        let pos = Position { x: 3.234, y: -1.223 };
-
-        tracing::debug!(?pos.x, ?pos.y);
-        log::debug!("😁 bridge 'log' to 'tracing'");
+        let _ = Builder::new("flowy").local(".").env_filter("debug").build().unwrap();
+        tracing::info!("😁  tracing::info call");
+        log::debug!("😁 log::debug call");
 
         say("hello world");
     }
 
+    #[test]
+    fn test_log2() {
+        let env_filter = EnvFilter::new("Debug");
+        let file_appender = tracing_appender::rolling::daily(".", "flowy_log_test");
+        let (non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
+
+        let subscriber = tracing_subscriber::fmt()
+            .with_target(false)
+            .with_max_level(tracing::Level::TRACE)
+            .with_writer(std::io::stderr)
+            .with_thread_ids(true)
+            .with_writer(non_blocking)
+            .json()
+            .compact()
+            .finish()
+            .with(env_filter);
+
+        let formatting_layer = FlowyFormattingLayer::new(std::io::stdout);
+        let _ = set_global_default(subscriber.with(JsonStorageLayer).with(formatting_layer))
+            .map_err(|e| format!("{:?}", e))
+            .unwrap();
+
+        let _ = LogTracer::builder()
+            .with_max_level(LevelFilter::Trace)
+            .init()
+            .map_err(|e| format!("{:?}", e))
+            .unwrap();
+
+        tracing::info!("😁");
+    }
+
     #[tracing::instrument(name = "say")]
     fn say(s: &str) {
         log::info!("{}", s);