Refactor: Cleanup program-runtime dyn Traits (#21395)

* Unifies dyn Trait ComputeMeter, ThisComputeMeter and TransactionComputeMeter.

* Unifies dyn Trait Logger and ThisLogger.

* Moves Logger to log_collector.rs

* Unifies Logger and LogCollector.

* Removes inner RefCell from LogCollector.

* Adds the log::debug!() message to ic_logger_msg!() again.

program-runtime/src/log_collector.rs

@@ -1,48 +1,79 @@
-use std::cell::RefCell;
+pub use log;
+use std::{cell::RefCell, rc::Rc};
 
 const LOG_MESSAGES_BYTES_LIMIT: usize = 10 * 1000;
 
 #[derive(Default)]
-struct LogCollectorInner {
+pub struct LogCollector {
     messages: Vec<String>,
     bytes_written: usize,
     limit_warning: bool,
 }
 
-#[derive(Default)]
-pub struct LogCollector {
-    inner: RefCell<LogCollectorInner>,
-}
-
 impl LogCollector {
-    pub fn log(&self, message: &str) {
-        let mut inner = self.inner.borrow_mut();
-        let bytes_written = inner.bytes_written.saturating_add(message.len());
+    pub fn log(&mut self, message: &str) {
+        let bytes_written = self.bytes_written.saturating_add(message.len());
         if bytes_written >= LOG_MESSAGES_BYTES_LIMIT {
-            if !inner.limit_warning {
-                inner.limit_warning = true;
-                inner.messages.push(String::from("Log truncated"));
+            if !self.limit_warning {
+                self.limit_warning = true;
+                self.messages.push(String::from("Log truncated"));
             }
         } else {
-            inner.bytes_written = bytes_written;
-            inner.messages.push(message.to_string());
+            self.bytes_written = bytes_written;
+            self.messages.push(message.to_string());
         }
     }
+
+    pub fn new_ref() -> Rc<RefCell<Self>> {
+        Rc::new(RefCell::new(Self::default()))
+    }
 }
 
 impl From<LogCollector> for Vec<String> {
     fn from(log_collector: LogCollector) -> Self {
-        log_collector.inner.into_inner().messages
+        log_collector.messages
     }
 }
 
+/// Convenience macro to log a message with an `Option<Rc<RefCell<LogCollector>>>`
+#[macro_export]
+macro_rules! ic_logger_msg {
+    ($log_collector:expr, $message:expr) => {
+        $crate::log_collector::log::debug!("{}", $message);
+        if let Some(log_collector) = $log_collector.as_ref() {
+            if let Ok(mut log_collector) = log_collector.try_borrow_mut() {
+                log_collector.log($message);
+            }
+        }
+    };
+    ($log_collector:expr, $fmt:expr, $($arg:tt)*) => {
+        $crate::log_collector::log::debug!($fmt, $($arg)*);
+        if let Some(log_collector) = $log_collector.as_ref() {
+            if let Ok(mut log_collector) = log_collector.try_borrow_mut() {
+                log_collector.log(&format!($fmt, $($arg)*));
+            }
+        }
+    };
+}
+
+/// Convenience macro to log a message with an `InvokeContext`
+#[macro_export]
+macro_rules! ic_msg {
+    ($invoke_context:expr, $message:expr) => {
+        $crate::ic_logger_msg!($invoke_context.get_log_collector(), $message)
+    };
+    ($invoke_context:expr, $fmt:expr, $($arg:tt)*) => {
+        $crate::ic_logger_msg!($invoke_context.get_log_collector(), $fmt, $($arg)*)
+    };
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
 
     #[test]
     fn test_log_messages_bytes_limit() {
-        let lc = LogCollector::default();
+        let mut lc = LogCollector::default();
 
         for _i in 0..LOG_MESSAGES_BYTES_LIMIT * 2 {
             lc.log("x");