feat:v1.1.0

Author: ltpp-universe

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "hyperlane-log"
-version = "1.0.0"
+version = "1.1.0"
 edition = "2021"
 authors = ["ltpp-universe <root@ltpp.vip>"] 
 license = "MIT"
@@ -17,7 +17,7 @@ exclude = [
 
 [dependencies]
 file-operation = "0.3.0"
-http-type = "2.27.1"
+http-type = "2.28.0"
 hyperlane-time = "0.0.3"
 lombok-macros = "1.7.0"
 once_cell = "1.20.2"

Cargo.toml

@@ -27,7 +27,7 @@ cargo add hyperlane-log
 
 ```rust
 use hyperlane_log::*;
-let log: Log = Log::new("./logs", 1_024_000);
+let log: Log = Log::new("./logs", 1_024_000, 360);
 let log_thread: JoinHandle<()> = log_run(&log);
 log.error("error data!", |error| {
     let write_data: String = format!("User error func =>  {:?}\n", error);

readme.md

@@ -3,7 +3,7 @@ fn test() {
     use crate::*;
     use std::thread;
     use std::time::Duration;
-    let log: Log = Log::new("./logs", 1_024_000);
+    let log: Log = Log::new("./logs", 1_024_000, 360);
     let _log_thread: JoinHandle<()> = log_run(&log);
     log.error("error data => ", |error| {
         let write_data: String = format!("User error func =>  {:?}\n", error);
@@ -25,7 +25,7 @@ fn test_more_log_first() {
     use crate::*;
     use std::thread;
     use std::time::Duration;
-    let log: Log = Log::new("./logs", 0);
+    let log: Log = Log::new("./logs", 0, 360);
     let _log_thread: JoinHandle<()> = log_run(&log);
     log.error("error data => ", |error| {
         let write_data: String = format!("User error func =>  {:?}\n", error);
@@ -48,7 +48,7 @@ fn test_more_log_second() {
     use std::thread;
     use std::time::Duration;
     thread::sleep(Duration::new(4, 0));
-    let log: Log = Log::new("./logs", 1_024);
+    let log: Log = Log::new("./logs", 1_024, 360);
     let _log_thread: JoinHandle<()> = log_run(&log);
     let times: i32 = 1000;
     for _ in 0..times {

src/cfg.rs

@@ -5,3 +5,4 @@ pub static DEBUG_DIR: &str = "debug";
 pub static LOG_EXTION: &str = "log";
 pub static DEFAULT_LOG_FILE_START_IDX: usize = 1;
 pub static DEFAULT_LOG_FILE_SIZE: usize = 1_024_000_000;
+pub static DEFAULT_LOG_INTERVAL_MILLIS: usize = 1;

src/log/constant.rs

@@ -4,12 +4,15 @@ use super::{
     r#type::{Log, LogListArcLock},
     utils::*,
 };
-use crate::BoxLogFunc;
+use crate::{ArcLogFunc, ListLog};
 use file_operation::*;
 use http_type::*;
 use hyperlane_time::*;
 use once_cell::sync::Lazy;
-use std::sync::{Arc, RwLock};
+use std::{
+    sync::{Arc, RwLock},
+    vec,
+};
 
 static LOG_ERROR_QUEUE: Lazy<LogListArcLock> = Lazy::new(|| Arc::new(RwLock::new(Vec::new())));
 static LOG_INFO_QUEUE: Lazy<LogListArcLock> = Lazy::new(|| Arc::new(RwLock::new(Vec::new())));
@@ -21,24 +24,26 @@ impl Default for Log {
         Self {
             path: DEFAULT_LOG_DIR.to_owned(),
             file_size: DEFAULT_LOG_FILE_SIZE,
+            interval_millis: DEFAULT_LOG_INTERVAL_MILLIS,
         }
     }
 }
 
 impl Log {
     #[inline]
-    pub fn new<T>(path: T, file_size: usize) -> Self
+    pub fn new<T>(path: T, file_size: usize, interval_millis: usize) -> Self
     where
         T: Into<String>,
     {
         Self {
             path: path.into(),
             file_size,
+            interval_millis,
         }
     }
 
     #[inline]
-    fn write(list: &mut Vec<(String, BoxLogFunc)>, path: &str) {
+    fn write(list: &mut Vec<(String, ArcLogFunc)>, path: &str) {
         for (log_string, func) in list.iter() {
             let out: String = func(log_string);
             let _ = write_to_file(path, &out.as_bytes());
@@ -54,7 +59,7 @@ impl Log {
         let data_string: String = data.into();
         {
             if let Ok(mut queue) = log_queue.write() {
-                queue.push((data_string, Box::new(func)));
+                queue.push((data_string, Arc::new(func)));
             }
         }
     }
@@ -103,26 +108,35 @@ impl Log {
 
     #[inline]
     pub(super) fn write_error(&self) {
-        if let Ok(mut error) = LOG_ERROR_QUEUE.write() {
-            Self::write(&mut *error, &self.get_log_path(ERROR_DIR));
-            error.clear();
-        }
+        let mut list: ListLog = if let Ok(mut error) = LOG_ERROR_QUEUE.write() {
+            let tmp_error: ListLog = error.drain(..).collect::<Vec<_>>();
+            tmp_error
+        } else {
+            vec![]
+        };
+        Self::write(&mut list, &self.get_log_path(ERROR_DIR));
     }
 
     #[inline]
     pub(super) fn write_info(&self) {
-        if let Ok(mut info) = LOG_INFO_QUEUE.write() {
-            Self::write(&mut *info, &self.get_log_path(INFO_DIR));
-            info.clear();
-        }
+        let mut list: ListLog = if let Ok(mut info) = LOG_INFO_QUEUE.write() {
+            let tmp_info: ListLog = info.drain(..).collect::<Vec<_>>();
+            tmp_info
+        } else {
+            vec![]
+        };
+        Self::write(&mut list, &self.get_log_path(INFO_DIR));
     }
 
     #[inline]
     pub(super) fn write_debug(&self) {
-        if let Ok(mut debug) = LOG_DEBUG_QUEUE.write() {
-            Self::write(&mut *debug, &self.get_log_path(DEBUG_DIR));
-            debug.clear();
-        }
+        let mut list: ListLog = if let Ok(mut debug) = LOG_DEBUG_QUEUE.write() {
+            let tmp_debug: ListLog = debug.drain(..).collect::<Vec<_>>();
+            tmp_debug
+        } else {
+            vec![]
+        };
+        Self::write(&mut list, &self.get_log_path(DEBUG_DIR));
     }
 
     #[inline]

src/log/impl.rs

@@ -1,6 +1,6 @@
 use crate::Log;
 use recoverable_spawn::*;
-use std::sync::Arc;
+use std::{sync::Arc, thread::sleep, time::Duration};
 
 #[inline]
 pub fn log_run(log: &Log) -> JoinHandle<()> {
@@ -9,14 +9,26 @@ pub fn log_run(log: &Log) -> JoinHandle<()> {
         let arc_error_log_clone: Arc<Log> = Arc::clone(&arc_log);
         let arc_info_log_clone: Arc<Log> = Arc::clone(&arc_log);
         let arc_debug_log_clone: Arc<Log> = Arc::clone(&arc_log);
-        let error_log_thread: JoinHandle<()> = recoverable_spawn(move || loop {
-            arc_error_log_clone.write_error();
+        let error_log_thread: JoinHandle<()> = recoverable_spawn(move || {
+            let interval_millis: u64 = *arc_error_log_clone.get_interval_millis() as u64;
+            loop {
+                arc_error_log_clone.write_error();
+                sleep(Duration::from_millis(interval_millis));
+            }
         });
-        let info_log_thread: JoinHandle<()> = recoverable_spawn(move || loop {
-            arc_info_log_clone.write_info();
+        let info_log_thread: JoinHandle<()> = recoverable_spawn(move || {
+            let interval_millis: u64 = *arc_info_log_clone.get_interval_millis() as u64;
+            loop {
+                arc_info_log_clone.write_info();
+                sleep(Duration::from_millis(interval_millis));
+            }
         });
-        let debug_log_thread: JoinHandle<()> = recoverable_spawn(move || loop {
-            arc_debug_log_clone.write_debug();
+        let debug_log_thread: JoinHandle<()> = recoverable_spawn(move || {
+            let interval_millis: u64 = *arc_debug_log_clone.get_interval_millis() as u64;
+            loop {
+                arc_debug_log_clone.write_debug();
+                sleep(Duration::from_millis(interval_millis));
+            }
         });
         let _ = error_log_thread.join();
         let _ = info_log_thread.join();

src/log/thread.rs

@@ -1,14 +1,17 @@
 use super::r#trait::LogFuncTrait;
 use http_type::*;
 use lombok_macros::Lombok;
+use std::sync::Arc;
 
-pub type LogListArcLock = ArcRwLock<Vec<(String, BoxLogFunc)>>;
+pub type ListLog = Vec<(String, ArcLogFunc)>;
+pub type LogListArcLock = ArcRwLock<ListLog>;
 pub type LogArcLock = ArcRwLock<Log>;
 pub type LogFunc = dyn LogFuncTrait;
-pub type BoxLogFunc = Box<LogFunc>;
+pub type ArcLogFunc = Arc<LogFunc>;
 
 #[derive(Debug, Clone, Lombok)]
 pub struct Log {
     pub(super) path: String,
     pub(super) file_size: usize,
+    pub(super) interval_millis: usize,
 }