Merge pull request #134 from horizonx-tech/feature/logging

add logger

chainsight-cdk-macros/src/lib.rs

@@ -147,6 +147,11 @@ pub fn define_get_ethereum_address(input: TokenStream) -> TokenStream {
     web3::define_get_ethereum_address(input)
 }
 
+#[proc_macro]
+pub fn define_logger(input: TokenStream) -> TokenStream {
+    utils::define_logger(input)
+}
+
 #[proc_macro_derive(ContractEvent)]
 pub fn contract_event_derive(input: TokenStream) -> TokenStream {
     web3::contract_event_derive(input)

chainsight-cdk-macros/src/snapshots/chainsight_cdk_macros__utils__tests__snapshot__define_logger.snap

@@ -0,0 +1,41 @@
+---
+source: chainsight-cdk-macros/src/utils.rs
+expression: formatted
+---
+use chainsight_cdk::log::{Logger, LoggerImpl};
+#[candid::candid_method(query)]
+#[ic_cdk::query]
+fn tail_logs(rows: usize) -> Vec<String> {
+    _logger().tail(rows)
+}
+#[candid::candid_method(update)]
+#[ic_cdk::update]
+#[chainsight_cdk_macros::only_controller]
+fn drain_logs(rows: usize) -> Vec<String> {
+    _logger().drain(rows)
+}
+#[ic_cdk::init]
+fn init_logger() {
+    schedule_cleanup();
+}
+#[ic_cdk::post_upgrade]
+fn post_upgrade_logger() {
+    schedule_cleanup();
+}
+fn schedule_cleanup() {
+    ic_cdk_timers::set_timer_interval(std::time::Duration::from_secs(86400u64), || {
+        ic_cdk::spawn(async {
+            _logger().sweep(7u8);
+        })
+    });
+    _logger().info(
+        format!(
+            "cleanup sheduled: interval = {} sec. retention days = {}",
+            86400u64, 7u8
+        )
+        .as_str(),
+    );
+}
+fn _logger() -> LoggerImpl {
+    LoggerImpl::new(Some("Logger"))
+}

chainsight-cdk-macros/src/utils.rs

@@ -1,6 +1,9 @@
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, DeriveInput};
+use syn::{
+    parse::{Parse, ParseStream},
+    parse_macro_input, DeriveInput, LitInt, Result,
+};
 
 pub fn chainsight_common(_input: TokenStream) -> TokenStream {
     chainsight_common_internal().into()
@@ -14,6 +17,83 @@ fn chainsight_common_internal() -> proc_macro2::TokenStream {
     }
 }
 
+#[derive(Default)]
+struct DefineLoggerArgs {
+    retention_days: Option<u8>,
+    cleanup_interval_days: Option<u8>,
+}
+impl Parse for DefineLoggerArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        if input.is_empty() {
+            return Ok(DefineLoggerArgs {
+                retention_days: None,
+                cleanup_interval_days: None,
+            });
+        }
+        let retention_days: Option<LitInt> = input.parse()?;
+        let retention_days = retention_days.map(|x| x.base10_parse::<u8>().unwrap());
+        if input.parse::<syn::Token![,]>().is_err() {
+            return Ok(DefineLoggerArgs {
+                retention_days,
+                cleanup_interval_days: None,
+            });
+        }
+        let cleanup_interval_days: Option<LitInt> = input.parse()?;
+        Ok(DefineLoggerArgs {
+            retention_days,
+            cleanup_interval_days: cleanup_interval_days.map(|x| x.base10_parse().unwrap()),
+        })
+    }
+}
+pub fn define_logger(input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(input as DefineLoggerArgs);
+    define_logger_internal(args).into()
+}
+
+fn define_logger_internal(args: DefineLoggerArgs) -> proc_macro2::TokenStream {
+    let retention_days = args.retention_days.unwrap_or(7);
+    let cleanup_interval = args.cleanup_interval_days.unwrap_or(1) as u64 * 86400;
+    quote! {
+        use chainsight_cdk::log::{Logger, LoggerImpl};
+
+        #[candid::candid_method(query)]
+        #[ic_cdk::query]
+        fn tail_logs(rows: usize) -> Vec<String> {
+            _logger().tail(rows)
+        }
+
+        #[candid::candid_method(update)]
+        #[ic_cdk::update]
+        #[chainsight_cdk_macros::only_controller]
+        fn drain_logs(rows: usize) -> Vec<String> {
+            _logger().drain(rows)
+        }
+
+        #[ic_cdk::init]
+        fn init_logger() {
+            schedule_cleanup();
+        }
+
+        #[ic_cdk::post_upgrade]
+        fn post_upgrade_logger() {
+            schedule_cleanup();
+        }
+
+        fn schedule_cleanup() {
+            ic_cdk_timers::set_timer_interval(std::time::Duration::from_secs(#cleanup_interval), || {
+                ic_cdk::spawn(async {
+                    _logger().sweep(#retention_days);
+                })
+            });
+            _logger().info(format!("cleanup sheduled: interval = {} sec. retention days = {}", #cleanup_interval, #retention_days).as_str());
+        }
+
+        fn _logger() -> LoggerImpl {
+            LoggerImpl::new(Some("Logger"))
+        }
+    }
+}
+
 pub fn did_export(input: TokenStream) -> TokenStream {
     let args = parse_macro_input!(input as syn::LitStr);
     did_export_internal(args).into()
@@ -76,6 +156,15 @@ mod tests {
         assert_snapshot!("snapshot__chainsight_common", formatted);
     }
 
+    #[test]
+    fn test_snapshot_define_logger() {
+        let generated = define_logger_internal(Default::default());
+        let formatted = RustFmt::default()
+            .format_str(generated.to_string())
+            .expect("rustfmt failed");
+        assert_snapshot!("snapshot__define_logger", formatted);
+    }
+
     #[test]
     fn test_snapshot_did_export() {
         let input = quote! {"sample_component"};

chainsight-cdk/Cargo.toml

@@ -27,6 +27,8 @@ derive_more = "0.99.17"
 lazy_static = "1.4.0"
 primitive-types = "0.12.1"
 Inflector = "0.11.4"
+time = "0.3.37"
+ic-cdk-timers = "0.11.0"
 
 [dev-dependencies]
 insta = { version = "1.33.0", features = ["yaml"] }

chainsight-cdk/src/core/mod.rs

@@ -1,4 +1,5 @@
 mod env;
+mod time;
 pub use core::*;
 pub use env::*;
 pub use time::*;

chainsight-cdk/src/lib.rs

@@ -5,6 +5,7 @@ pub mod core;
 pub mod indexer;
 pub mod initializer;
 pub mod lens;
+pub mod log;
 pub mod metric;
 pub mod rpc;
 pub mod storage;