[Rust] Replace `log` with `tracing`

- Added more documentation
- Replaced global named logger for plugins, fixing the issue when the CU has multiple (e.g. statically linked demo)
- Simplified some misc code

This is a breaking change, but I believe there is no better time to make it, we cannot continue to use the `log` crate, it is too limited for our needs.

4 files changed, 51 insertions, 47 deletions

diff --git a/view/minidump/Cargo.toml b/view/minidump/Cargo.toml
index aa1ff40e..fed4a611 100644
--- a/view/minidump/Cargo.toml
+++ b/view/minidump/Cargo.toml
@@ -10,5 +10,4 @@ crate-type = ["cdylib"]
 [dependencies]
 binaryninja.workspace = true
 binaryninjacore-sys.workspace = true
-log = "0.4"
 minidump = "0.23.0"
\ No newline at end of file
diff --git a/view/minidump/src/command.rs b/view/minidump/src/command.rs
index 81629f55..2f28b8b5 100644
--- a/view/minidump/src/command.rs
+++ b/view/minidump/src/command.rs
@@ -1,12 +1,12 @@
 use std::str;
 
-use log::{debug, error, info};
 use minidump::{Minidump, MinidumpMemoryInfoList};
 
 use binaryninja::binary_view::{BinaryView, BinaryViewBase, BinaryViewExt};
+use binaryninja::tracing;
 
 pub fn print_memory_information(bv: &BinaryView) {
-    debug!("Printing memory information");
+    tracing::debug!("Printing memory information");
     if let Some(minidump_bv) = bv.parent_view() {
         if let Some(read_buffer) = minidump_bv.read_buffer(0, minidump_bv.len() as usize) {
             if let Ok(minidump_obj) = Minidump::read(read_buffer.get_data()) {
@@ -15,27 +15,27 @@ pub fn print_memory_information(bv: &BinaryView) {
                     match memory_info_list.print(&mut memory_info_list_writer) {
                         Ok(_) => {
                             if let Ok(memory_info_str) = str::from_utf8(&memory_info_list_writer) {
-                                info!("{memory_info_str}");
+                                tracing::info!("{memory_info_str}");
                             } else {
-                                error!("Could not convert the memory information description from minidump into a valid string");
+                                tracing::error!("Could not convert the memory information description from minidump into a valid string");
                             }
                         }
                         Err(_) => {
-                            error!("Could not get memory information from minidump");
+                            tracing::error!("Could not get memory information from minidump");
                         }
                     }
                 } else {
-                    error!(
+                    tracing::error!(
                         "Could not parse a valid MinidumpMemoryInfoList stream from the minidump"
                     );
                 }
             } else {
-                error!("Could not parse a valid minidump file from the parent binary view's data buffer");
+                tracing::error!("Could not parse a valid minidump file from the parent binary view's data buffer");
             }
         } else {
-            error!("Could not read data from parent binary view");
+            tracing::error!("Could not read data from parent binary view");
         }
     } else {
-        error!("Could not get the parent binary view");
+        tracing::error!("Could not get the parent binary view");
     }
 }
diff --git a/view/minidump/src/lib.rs b/view/minidump/src/lib.rs
index 64aaddd6..00fed601 100644
--- a/view/minidump/src/lib.rs
+++ b/view/minidump/src/lib.rs
@@ -1,8 +1,7 @@
 use binaryninja::binary_view::BinaryView;
 use binaryninja::command::{register_command, Command};
 use binaryninja::custom_binary_view::register_view_type;
-use binaryninja::logger::Logger;
-use log::{debug, LevelFilter};
+use binaryninja::tracing;
 
 mod command;
 mod view;
@@ -22,14 +21,11 @@ impl Command for PrintMemoryInformationCommand {
 #[no_mangle]
 #[allow(non_snake_case)]
 pub extern "C" fn CorePluginInit() -> bool {
-    Logger::new("Minidump")
-        .with_level(LevelFilter::Trace)
-        .init();
-
-    debug!("Registering minidump binary view type");
+    binaryninja::tracing_init!("Minidump");
+    tracing::debug!("Registering minidump binary view type");
     register_view_type("Minidump", "Minidump", view::MinidumpBinaryViewType::new);
 
-    debug!("Registering minidump plugin commands");
+    tracing::debug!("Registering minidump plugin commands");
     register_command(
         "Minidump\\[DEBUG] Print Minidump Memory Information",
         "Print a human-readable description of the contents of the MinidumpMemoryInfoList stream in the loaded minidump",
diff --git a/view/minidump/src/view.rs b/view/minidump/src/view.rs
index 413fafa1..32fde030 100644
--- a/view/minidump/src/view.rs
+++ b/view/minidump/src/view.rs
@@ -3,7 +3,6 @@ use std::ops::Range;
 
 use binaryninja::section::Section;
 use binaryninja::segment::{Segment, SegmentFlags};
-use log::{debug, error, info, warn};
 use minidump::format::MemoryProtection;
 use minidump::{
     Minidump, MinidumpMemory64List, MinidumpMemoryInfoList, MinidumpMemoryList, MinidumpModuleList,
@@ -16,7 +15,7 @@ use binaryninja::custom_binary_view::{
     CustomViewBuilder,
 };
 use binaryninja::platform::Platform;
-use binaryninja::Endianness;
+use binaryninja::{tracing, Endianness};
 
 type BinaryViewResult<R> = binaryninja::binary_view::Result<R>;
 
@@ -66,7 +65,7 @@ impl CustomBinaryViewType for MinidumpBinaryViewType {
         data: &BinaryView,
         builder: CustomViewBuilder<'builder, Self>,
     ) -> BinaryViewResult<CustomView<'builder>> {
-        debug!("Creating MinidumpBinaryView from registered MinidumpBinaryViewType");
+        tracing::debug!("Creating MinidumpBinaryView from registered MinidumpBinaryViewType");
 
         let binary_view = builder.create::<MinidumpBinaryView>(data, ());
         binary_view
@@ -131,7 +130,7 @@ impl MinidumpBinaryView {
                 ) {
                     self.set_default_platform(&platform);
                 } else {
-                    error!(
+                    tracing::error!(
                         "Could not parse valid system information from minidump: could not map system information in MinidumpSystemInfo stream (arch {:?}, endian {:?}, os {:?}) to a known architecture",
                         minidump_system_info.cpu,
                         minidump_obj.endian,
@@ -140,7 +139,9 @@ impl MinidumpBinaryView {
                     return Err(());
                 }
             } else {
-                error!("Could not parse system information from minidump: could not find a valid MinidumpSystemInfo stream");
+                tracing::error!(
+                    "Could not parse system information from minidump: could not find a valid MinidumpSystemInfo stream"
+                );
                 return Err(());
             }
 
@@ -153,19 +154,19 @@ impl MinidumpBinaryView {
             if let Ok(raw_stream) = minidump_obj.get_raw_stream(MinidumpMemory64List::STREAM_TYPE) {
                 if let Ok(base_rva_array) = raw_stream[8..16].try_into() {
                     let base_rva = u64::from_le_bytes(base_rva_array);
-                    debug!("Found BaseRVA value {:#x}", base_rva);
+                    tracing::debug!("Found BaseRVA value {:#x}", base_rva);
 
                     if let Ok(minidump_memory_list) =
                         minidump_obj.get_stream::<MinidumpMemory64List>()
                     {
                         let mut current_rva = base_rva;
                         for memory_segment in minidump_memory_list.iter() {
-                            debug!(
-                            "Found memory segment at RVA {:#x} with virtual address {:#x} and size {:#x}",
-                            current_rva,
-                            memory_segment.base_address,
-                            memory_segment.size,
-                        );
+                            tracing::debug!(
+                                "Found memory segment at RVA {:#x} with virtual address {:#x} and size {:#x}",
+                                current_rva,
+                                memory_segment.base_address,
+                                memory_segment.size,
+                            );
                             segment_data.push(SegmentData::from_addresses_and_size(
                                 current_rva,
                                 memory_segment.base_address,
@@ -175,15 +176,19 @@ impl MinidumpBinaryView {
                         }
                     }
                 } else {
-                    error!("Could not parse BaseRVA value shared by all entries in the MinidumpMemory64List stream")
+                    tracing::error!(
+                        "Could not parse BaseRVA value shared by all entries in the MinidumpMemory64List stream"
+                    )
                 }
             } else {
-                warn!("Could not read memory from minidump: could not find a valid MinidumpMemory64List stream. This minidump may not be a full memory dump. Trying to find partial dump memory from a MinidumpMemoryList now...");
+                tracing::warn!(
+                    "Could not read memory from minidump: could not find a valid MinidumpMemory64List stream. This minidump may not be a full memory dump. Trying to find partial dump memory from a MinidumpMemoryList now..."
+                );
                 // Memory segments in a regular memory dump (MinidumpMemoryList),
                 // i.e. one that does not include the full process memory data.
                 if let Ok(minidump_memory_list) = minidump_obj.get_stream::<MinidumpMemoryList>() {
                     for memory_segment in minidump_memory_list.by_addr() {
-                        debug!(
+                        tracing::debug!(
                             "Found memory segment at RVA {:#x} with virtual address {:#x} and size {:#x}",
                             memory_segment.desc.memory.rva,
                             memory_segment.base_address,
@@ -196,7 +201,9 @@ impl MinidumpBinaryView {
                         ));
                     }
                 } else {
-                    error!("Could not read any memory from minidump: could not find a valid MinidumpMemory64List stream or a valid MinidumpMemoryList stream.");
+                    tracing::error!(
+                        "Could not read any memory from minidump: could not find a valid MinidumpMemory64List stream or a valid MinidumpMemoryList stream."
+                    );
                 }
             }
 
@@ -208,7 +215,7 @@ impl MinidumpBinaryView {
             {
                 for memory_info in minidump_memory_info_list.iter() {
                     if let Some(memory_range) = memory_info.memory_range() {
-                        debug!(
+                        tracing::debug!(
                             "Found memory protection info for memory segment ranging from virtual address {:#x} to {:#x}: {:#?}",
                             memory_range.start,
                             memory_range.end,
@@ -235,15 +242,15 @@ impl MinidumpBinaryView {
                     let segment_memory_protection =
                         MinidumpBinaryView::translate_memory_protection(*segment_protection);
 
-                    info!(
+                    tracing::info!(
                         "Adding memory segment at virtual address {:#x} to {:#x}, from data range {:#x} to {:#x}, with protections readable {}, writable {}, executable {}",
-                         segment.mapped_addr_range.start,
-                         segment.mapped_addr_range.end,
-                         segment.rva_range.start,
-                         segment.rva_range.end,
-                         segment_memory_protection.readable,
-                         segment_memory_protection.writable,
-                         segment_memory_protection.executable,
+                        segment.mapped_addr_range.start,
+                        segment.mapped_addr_range.end,
+                        segment.rva_range.start,
+                        segment.rva_range.end,
+                        segment_memory_protection.readable,
+                        segment_memory_protection.writable,
+                        segment_memory_protection.executable,
                     );
 
                     let segment_flags = SegmentFlags::new()
@@ -258,7 +265,7 @@ impl MinidumpBinaryView {
                             .flags(segment_flags),
                     );
                 } else {
-                    error!(
+                    tracing::error!(
                         "Could not find memory protection information for memory segment from {:#x} to {:#x}", segment.mapped_addr_range.start,
                         segment.mapped_addr_range.end,
                     );
@@ -271,7 +278,7 @@ impl MinidumpBinaryView {
             // Sections can be named, and can span multiple segments.
             if let Ok(minidump_module_list) = minidump_obj.get_stream::<MinidumpModuleList>() {
                 for module_info in minidump_module_list.by_addr() {
-                    info!(
+                    tracing::info!(
                         "Found module with name {} at virtual address {:#x} with size {:#x}",
                         module_info.name,
                         module_info.base_address(),
@@ -287,10 +294,12 @@ impl MinidumpBinaryView {
                     );
                 }
             } else {
-                warn!("Could not find valid module information in minidump: could not find a valid MinidumpModuleList stream");
+                tracing::warn!(
+                    "Could not find valid module information in minidump: could not find a valid MinidumpModuleList stream"
+                );
             }
         } else {
-            error!("Could not parse data as minidump");
+            tracing::error!("Could not parse data as minidump");
             return Err(());
         }
         Ok(())