Merge pull request #54 from lambda-sh/vmarcella/improve-logging

lambda-rs-logging

Author: vmarcella

Cargo.lock

@@ -4,13 +4,15 @@
 members = [
     "crates/lambda-rs",
     "crates/lambda-rs-args",
+    "crates/lambda-rs-logging",
     "crates/lambda-rs-platform",
     "tools/obj_loader"
 ]
 
 default-members = [
     "crates/lambda-rs",
     "crates/lambda-rs-args",
+    "crates/lambda-rs-logging",
     "crates/lambda-rs-platform",
     "tools/obj_loader"
 ]

Cargo.toml

@@ -57,7 +57,7 @@ and can be added to your project by adding the following to your
 
 ```toml
 [dependencies]
-lambda-rs = "2023.1.29"
+lambda-rs = "2023.1.30"
 ```
 
 or from the CLI:
@@ -158,6 +158,7 @@ cargo run --example triangles
 - ### Packages
   - [x] (WIP) [lambda-rs-args](./crates/lambda-rs-args/README.md) -- Command line argument parsing.
   - [x] (WIP) [lambda-rs-platform](./crates/lambda-rs-platform/README.md) -- Dependency wrappers & platform support.
+  - [x] [lambda-rs-logging](./crates/lambda-rs-logging/README.md) -- Lightweight Logging API for lambda-rs packages.
   - [x] (WIP) [lambda-rs](./crates/lambda-rs/README.md) -- The public Lambda API.
 - ### Examples
   - [x] Minimal -- A minimal example of an application with a working window

README.md

@@ -0,0 +1,10 @@
+[package]
+name = "lambda-rs-logging"
+description = "Logging support for lambda-rs"
+version = "2023.1.30"
+edition = "2021"
+license = "MIT"
+
+[lib]
+name = "logging"
+path = "src/lib.rs"

crates/lambda-rs-logging/Cargo.toml

@@ -0,0 +1,49 @@
+# lambda-rs-logging
+![lambda-rs](https://img.shields.io/crates/d/lambda-rs-logging)
+![lambda-rs](https://img.shields.io/crates/v/lambda-rs-logging)
+
+A simple logger implementation for lamba-rs crates. Inspired by
+python's [logging](https://docs.python.org/3/library/logging.html) module.
+
+
+# Installation
+First, add the following to your `Cargo.toml`:
+```toml
+[dependencies]
+lambda-rs-logging = "2023.1.30"
+```
+
+or run this command from your project directory:
+```bash
+cargo add lambda-rs-logging
+```
+
+# Getting started
+## Using the global logger
+```rust
+use logging;
+
+fn main() {
+  logging::trace!("Hello world");
+  logging::debug!("Hello world");
+  logging::info!("Hello world");
+  logging::warn!("Hello world");
+  logging::error!("Hello world");
+  logging::fatal!("Hello world");
+}
+```
+
+## Using an instance of the logger
+```rust
+use logging::Logger;
+
+fn main() {
+  let logger = Logger::new("my-logger");
+  logger.trace("Hello world");
+  logger.debug("Hello world");
+  logger.info("Hello world");
+  logger.warn("Hello world");
+  logger.error("Hello world");
+  logger.fatal("Hello world");
+}
+```

crates/lambda-rs-logging/README.md

@@ -0,0 +1,164 @@
+//! Log handling implementations for the logger.
+
+use std::{
+  fmt::Debug,
+  fs::OpenOptions,
+  io::Write,
+  time::SystemTime,
+};
+
+use crate::LogLevel;
+
+pub trait Handler {
+  fn trace(&mut self, message: String);
+  fn debug(&mut self, message: String);
+  fn info(&mut self, message: String);
+  fn warn(&mut self, message: String);
+  fn error(&mut self, message: String);
+  fn fatal(&mut self, message: String);
+}
+
+/// A handler that logs to a file.
+
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct FileHandler {
+  file: String,
+  log_buffer: Vec<String>,
+}
+
+impl FileHandler {
+  pub fn new(file: String) -> Self {
+    Self {
+      file,
+      log_buffer: Vec::new(),
+    }
+  }
+
+  /// Logs a message to the file.
+  fn log(&mut self, log_level: LogLevel, message: String) {
+    let timestamp = SystemTime::now()
+      .duration_since(SystemTime::UNIX_EPOCH)
+      .unwrap()
+      .as_secs();
+
+    let log_message = format!("[{}]-[{:?}]: {}", timestamp, log_level, message);
+
+    let colored_message = match log_level {
+      LogLevel::TRACE => format!("\x1B[37m{}\x1B[0m", log_message),
+      LogLevel::DEBUG => format!("\x1B[35m{}\x1B[0m", log_message),
+      LogLevel::INFO => format!("\x1B[32m{}\x1B[0m", log_message),
+      LogLevel::WARN => format!("\x1B[33m{}\x1B[0m", log_message),
+      LogLevel::ERROR => format!("\x1B[31;1m{}\x1B[0m", log_message),
+      LogLevel::FATAL => format!("\x1B[31;1m{}\x1B[0m", log_message),
+    };
+
+    self.log_buffer.push(colored_message);
+
+    // Flush buffer every ten messages.
+    if self.log_buffer.len() < 10 {
+      return;
+    }
+
+    let log_message = self.log_buffer.join("\n");
+
+    let mut file = OpenOptions::new()
+      .append(true)
+      .create(true)
+      .open(self.file.clone())
+      .unwrap();
+
+    file
+      .write_all(log_message.as_bytes())
+      .expect("Unable to write data");
+
+    self.log_buffer.clear();
+  }
+}
+
+impl Handler for FileHandler {
+  fn trace(&mut self, message: String) {
+    self.log(LogLevel::TRACE, message)
+  }
+
+  fn debug(&mut self, message: String) {
+    self.log(LogLevel::DEBUG, message)
+  }
+
+  fn info(&mut self, message: String) {
+    self.log(LogLevel::INFO, message)
+  }
+
+  fn warn(&mut self, message: String) {
+    self.log(LogLevel::WARN, message)
+  }
+
+  fn error(&mut self, message: String) {
+    self.log(LogLevel::ERROR, message)
+  }
+
+  fn fatal(&mut self, message: String) {
+    self.log(LogLevel::FATAL, message)
+  }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
+pub struct ConsoleHandler {
+  name: String,
+}
+
+impl ConsoleHandler {
+  pub fn new(name: &str) -> Self {
+    return Self {
+      name: name.to_string(),
+    };
+  }
+
+  fn log(&mut self, log_level: LogLevel, message: String) {
+    let timestamp = SystemTime::now()
+      .duration_since(SystemTime::UNIX_EPOCH)
+      .unwrap()
+      .as_secs();
+
+    let log_message = format!(
+      "[{}]-[{:?}]-[{}]: {}",
+      timestamp, log_level, self.name, message
+    );
+
+    let colored_message = match log_level {
+      LogLevel::TRACE => format!("\x1B[37m{}\x1B[0m", log_message),
+      LogLevel::DEBUG => format!("\x1B[35m{}\x1B[0m", log_message),
+      LogLevel::INFO => format!("\x1B[32m{}\x1B[0m", log_message),
+      LogLevel::WARN => format!("\x1B[33m{}\x1B[0m", log_message),
+      LogLevel::ERROR => format!("\x1B[31;1m{}\x1B[0m", log_message),
+      LogLevel::FATAL => format!("\x1B[31;1m{}\x1B[0m", log_message),
+    };
+
+    println!("{}", colored_message);
+  }
+}
+
+impl Handler for ConsoleHandler {
+  fn trace(&mut self, message: String) {
+    self.log(LogLevel::TRACE, message);
+  }
+
+  fn debug(&mut self, message: String) {
+    self.log(LogLevel::DEBUG, message);
+  }
+
+  fn info(&mut self, message: String) {
+    self.log(LogLevel::INFO, message);
+  }
+
+  fn warn(&mut self, message: String) {
+    self.log(LogLevel::WARN, message);
+  }
+
+  fn error(&mut self, message: String) {
+    self.log(LogLevel::ERROR, message);
+  }
+
+  fn fatal(&mut self, message: String) {
+    self.log(LogLevel::FATAL, message);
+  }
+}