[add] macros for utilizing the global logger packaged with the logging crate.

Author: vmarcella

crates/lambda-rs-logging/src/handler.rs

@@ -1,6 +1,7 @@
 //! Log handling implementations for the logger.
 
 use std::{
+  fmt::Debug,
   fs::OpenOptions,
   io::Write,
   time::SystemTime,
@@ -18,6 +19,8 @@ pub trait Handler {
 }
 
 /// A handler that logs to a file.
+
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
 pub struct FileHandler {
   file: String,
   log_buffer: Vec<String>,
@@ -98,13 +101,16 @@ impl Handler for FileHandler {
   }
 }
 
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
 pub struct ConsoleHandler {
   name: String,
 }
 
 impl ConsoleHandler {
-  pub fn new(name: String) -> Self {
-    return Self { name };
+  pub fn new(name: &str) -> Self {
+    return Self {
+      name: name.to_string(),
+    };
   }
 
   fn log(&mut self, log_level: LogLevel, message: String) {

crates/lambda-rs-logging/src/lib.rs

@@ -1,13 +1,6 @@
 //! A simple logging library for lambda-rs crates.
 
-use std::{
-  fs::OpenOptions,
-  io::Write,
-  time::{
-    SystemTime,
-    UNIX_EPOCH,
-  },
-};
+use std::fmt::Debug;
 
 /// A trait for handling log messages.
 pub mod handler;
@@ -31,14 +24,32 @@ pub struct Logger {
 }
 
 impl Logger {
-  pub fn new(level: LogLevel, name: String) -> Self {
+  /// Creates a new logger with the given log level and name.
+  pub fn new(level: LogLevel, name: &str) -> Self {
     Self {
-      name,
+      name: name.to_string(),
       level,
       handlers: Vec::new(),
     }
   }
 
+  /// Returns the global logger.
+  pub fn global() -> &'static mut Self {
+    // TODO(vmarcella): Fix the instantiation for the global logger.
+    unsafe {
+      if LOGGER.is_none() {
+        LOGGER = Some(Logger {
+          level: LogLevel::TRACE,
+          name: "lambda-rs".to_string(),
+          handlers: vec![Box::new(handler::ConsoleHandler::new("lambda-rs"))],
+        });
+      }
+    };
+    return unsafe { &mut LOGGER }
+      .as_mut()
+      .expect("Logger not initialized");
+  }
+
   /// Adds a handler to the logger. Handlers are called in the order they
   /// are added.
   pub fn add_handler(&mut self, handler: Box<dyn handler::Handler>) {
@@ -114,3 +125,51 @@ impl Logger {
     std::process::exit(1);
   }
 }
+
+static mut LOGGER: Option<Logger> = None;
+
+/// Trace logging macro using the global logger instance.
+#[macro_export]
+macro_rules! trace {
+  ($($arg:tt)*) => {
+      Logger::global().trace(format!("{}", format_args!($($arg)*)));
+  };
+}
+
+/// Trace logging macro using the global logger instance.
+#[macro_export]
+macro_rules! debug {
+  ($($arg:tt)*) => {
+      Logger::global().debug(format!("{}", format_args!($($arg)*)));
+  };
+}
+
+/// Trace logging macro using the global logger instance.
+#[macro_export]
+macro_rules! info {
+  ($($arg:tt)*) => {
+      Logger::global().info(format!("{}", format_args!($($arg)*)));
+  };
+}
+
+// Define logging macros that use the global logger instance
+#[macro_export]
+macro_rules! warn {
+  ($($arg:tt)*) => {
+      Logger.global().warn(format!("{}", format_args!($($arg)*)));
+  };
+}
+
+#[macro_export]
+macro_rules! error {
+  ($($arg:tt)*) => {
+      Logger::global().error(format!("{}", format_args!($($arg)*)));
+  };
+}
+
+#[macro_export]
+macro_rules! fatal {
+  ($($arg:tt)*) => {
+      Logger::global().fatal(format!("{}", format_args!($($arg)*)));
+  };
+}

crates/lambda-rs/src/runtimes/application.rs

@@ -14,6 +14,7 @@ use lambda_platform::winit::{
   Loop,
   LoopBuilder,
 };
+#[macro_use]
 use logging::{
   handler::ConsoleHandler,
   Logger,
@@ -155,9 +156,6 @@ impl Runtime<(), String> for ApplicationRuntime {
       render_context,
     } = self;
 
-    let mut runtime_logger =
-      Logger::new(logging::LogLevel::TRACE, name.clone());
-    runtime_logger.add_handler(Box::new(ConsoleHandler::new(name.clone())));
     let mut active_render_context = Some(render_context);
 
     let publisher = event_loop.create_event_publisher();
@@ -239,10 +237,9 @@ impl Runtime<(), String> for ApplicationRuntime {
               })
             }
             _ => {
-              runtime_logger.warn(
-                format!("[WARN] Unhandled synthetic keyboard event: {:?}",
-                input)
-              );
+              logging::info!(
+                "[INFO] Unhandled synthetic keyboard event: {:?}",
+                input);
               None
             }
           },
@@ -352,7 +349,7 @@ impl Runtime<(), String> for ApplicationRuntime {
         WinitEvent::UserEvent(lambda_event) => match lambda_event {
           Events::Runtime { event, issued_at } => match event {
             RuntimeEvent::Initialized => {
-              runtime_logger.info(format!("Initializing all of the components for the runtime: {}", name));
+              logging::info!("Initializing all of the components for the runtime: {}", name);
               for component in &mut component_stack {
                 component.on_attach(active_render_context.as_mut().unwrap());
               }
@@ -382,22 +379,22 @@ impl Runtime<(), String> for ApplicationRuntime {
             .destroy();
 
 
-          runtime_logger.info(String::from("All resources were successfully deleted."));
+          logging::info!("All resources were successfully deleted.");
           None
         }
       };
 
       match mapped_event {
         Some(event) => {
-          runtime_logger.trace(format!("Sending event: {:?} to all components", event));
+          logging::trace!("Sending event: {:?} to all components", event);
 
           for component in &mut component_stack {
             let event_result = component.on_event(event.clone());
             match event_result {
               Ok(_) => {}
               Err(e) => {
                 let error = format!("[ERROR] A component has panicked while handling an event. {:?}", e);
-                runtime_logger.error(error.clone());
+                logging::error!("A component has panicked while handling an event. {:?}", e);
                 publisher.publish_event(Events::Runtime{event: RuntimeEvent::ComponentPanic{ message: error}, issued_at: Instant::now()});
               }
             }
@@ -412,10 +409,10 @@ impl Runtime<(), String> for ApplicationRuntime {
   /// When an application runtime starts, it will attach all of the components that
   /// have been added during the construction phase in the users code.
   fn on_start(&mut self) {
-    println!("[INFO] Starting the runtime {}", self.name);
+    logging::info!("Starting the runtime: {}", self.name);
   }
 
   fn on_stop(&mut self) {
-    println!("[INFO] Stopping {}", self.name)
+    logging::info!("Stopping the runtime: {}", self.name);
   }
 }