feat(ckBTC) Switch logs to json.

Author: leokazz

Cargo.lock

@@ -78,6 +78,7 @@ alias(
             "@crate_index//:candid",
             "@crate_index//:ic-cdk",
             "@crate_index//:ic-metrics-encoder",
+            "@crate_index//:serde_json",
         ],
     )
     for (name, features) in [
@@ -143,11 +144,14 @@ rust_test(
         "//rs/rosetta-api/icrc1",
         "//rs/rosetta-api/icrc1/ledger",
         "//rs/rust_canisters/canister_test",
+        "//rs/rust_canisters/http_types",
         "//rs/state_machine_tests",
         "//rs/test_utilities/load_wasm",
         "//rs/types/base_types",
         "@crate_index//:bitcoin",
         "@crate_index//:candid",
         "@crate_index//:ic-btc-interface",
+        "@crate_index//:serde_bytes",
+        "@crate_index//:serde_json",
     ],
 )

rs/bitcoin/ckbtc/minter/BUILD.bazel

@@ -38,6 +38,7 @@ ripemd = "0.1.1"
 scopeguard = "1.1.0"
 serde = "1.0.136"
 serde_bytes = "0.11"
+serde_json = "1.0.96"
 
 [dev-dependencies]
 bitcoin = "0.28.1"

rs/bitcoin/ckbtc/minter/Cargo.toml

@@ -47,6 +47,26 @@ pub const MINTER_FEE_PER_INPUT: u64 = 246;
 pub const MINTER_FEE_PER_OUTPUT: u64 = 7;
 pub const MINTER_FEE_CONSTANT: u64 = 52;
 
+#[derive(Clone, serde::Serialize, Deserialize, Debug)]
+pub enum Priority {
+    P0,
+    P1,
+}
+
+#[derive(Clone, serde::Serialize, Deserialize, Debug)]
+pub struct LogEntry {
+    pub timestamp: u64,
+    pub priority: Priority,
+    pub file: String,
+    pub line: u32,
+    pub message: String,
+}
+
+#[derive(Clone, Default, serde::Serialize, Deserialize, Debug)]
+pub struct Log {
+    pub entries: Vec<LogEntry>,
+}
+
 #[derive(CandidType, Debug, Deserialize, Serialize)]
 pub struct MinterInfo {
     pub min_confirmations: u32,

rs/bitcoin/ckbtc/minter/src/lib.rs

@@ -19,7 +19,7 @@ use ic_ckbtc_minter::updates::{
 use ic_ckbtc_minter::MinterInfo;
 use ic_ckbtc_minter::{
     state::eventlog::{Event, GetEventsArg},
-    storage,
+    storage, {Log, LogEntry, Priority},
 };
 use icrc_ledger_types::icrc1::account::Account;
 
@@ -209,32 +209,29 @@ fn http_request(req: HttpRequest) -> HttpResponse {
             .with_body_and_content_length(dashboard)
             .build()
     } else if req.path() == "/logs" {
-        use std::io::Write;
-        let mut buf = vec![];
-
-        writeln!(&mut buf, "P0 logs:").unwrap();
+        use serde_json;
+        let mut entries: Log = Default::default();
         for entry in export_logs(&ic_ckbtc_minter::logs::P0) {
-            writeln!(
-                &mut buf,
-                "{} {}:{} {}",
-                entry.timestamp, entry.file, entry.line, entry.message
-            )
-            .unwrap();
+            entries.entries.push(LogEntry {
+                timestamp: entry.timestamp,
+                priority: Priority::P0,
+                file: entry.file.to_string(),
+                line: entry.line,
+                message: entry.message,
+            });
         }
-
-        writeln!(&mut buf, "P1 logs:").unwrap();
         for entry in export_logs(&ic_ckbtc_minter::logs::P1) {
-            writeln!(
-                &mut buf,
-                "{} {}:{} {}",
-                entry.timestamp, entry.file, entry.line, entry.message
-            )
-            .unwrap();
+            entries.entries.push(LogEntry {
+                timestamp: entry.timestamp,
+                priority: Priority::P1,
+                file: entry.file.to_string(),
+                line: entry.line,
+                message: entry.message,
+            });
         }
-
         HttpResponseBuilder::ok()
-            .header("Content-Type", "text/plain; charset=utf-8")
-            .with_body_and_content_length(buf)
+            .header("Content-Type", "application/json; charset=utf-8")
+            .with_body_and_content_length(serde_json::to_string(&entries).unwrap_or_default())
             .build()
     } else {
         HttpResponseBuilder::not_found().build()

rs/bitcoin/ckbtc/minter/src/main.rs

@@ -4,6 +4,7 @@ use candid::{Decode, Encode, Nat, Principal};
 use ic_base_types::{CanisterId, PrincipalId};
 use ic_bitcoin_canister_mock::{OutPoint, PushUtxoToAddress, Utxo};
 use ic_btc_interface::Network;
+use ic_canisters_http_types::{HttpRequest, HttpResponse};
 use ic_ckbtc_kyt::{InitArg as KytInitArg, KytMode, LifecycleArg, SetApiKeyArg};
 use ic_ckbtc_minter::lifecycle::init::{InitArgs as CkbtcMinterInitArgs, MinterArg};
 use ic_ckbtc_minter::lifecycle::upgrade::UpgradeArgs;
@@ -577,6 +578,24 @@ impl CkBtcSetup {
         .unwrap()
     }
 
+    pub fn get_logs(&self) -> HttpResponse {
+        let request = HttpRequest {
+            method: "".to_string(),
+            url: "/logs".to_string(),
+            headers: vec![],
+            body: serde_bytes::ByteBuf::new(),
+        };
+        Decode!(
+            &assert_reply(
+                self.env
+                    .execute_ingress(self.minter_id, "http_request", Encode!(&request).unwrap(),)
+                    .expect("failed to get minter info")
+            ),
+            HttpResponse
+        )
+        .unwrap()
+    }
+
     pub fn refresh_fee_percentiles(&self) {
         Decode!(
             &assert_reply(
@@ -899,3 +918,25 @@ fn test_min_retrieval_amount() {
     let retrieve_btc_min_amount = ckbtc.get_minter_info().retrieve_btc_min_amount;
     assert_eq!(retrieve_btc_min_amount, 200_000);
 }
+
+#[test]
+fn test_get_logs() {
+    use ic_ckbtc_minter::Log;
+    let ckbtc = CkBtcSetup::new();
+
+    let ans = ckbtc.get_logs();
+    let binding = ans.body.into_vec();
+    let logs = std::str::from_utf8(&binding).unwrap();
+    let logs_json: serde_json::Value = serde_json::from_str(logs).unwrap();
+    let decoded_logs: Log = serde_json::from_value(logs_json).unwrap();
+    assert_eq!(decoded_logs.entries.len(), 0);
+
+    let _main_address = ckbtc.get_btc_address(Principal::from(ckbtc.minter_id));
+
+    let ans = ckbtc.get_logs();
+    let binding = ans.body.into_vec();
+    let logs = std::str::from_utf8(&binding).unwrap();
+    let logs_json: serde_json::Value = serde_json::from_str(logs).unwrap();
+    let decoded_logs: Log = serde_json::from_value(logs_json).unwrap();
+    assert_eq!(decoded_logs.entries.len(), 2);
+}