Include metadata into LogMessage.

Added default log metadata, message and builder.

logging-lib/src/messages.rs

@@ -1,26 +1,34 @@
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
+use std::collections::HashMap;
 
-#[derive(Serialize, Deserialize)]
+pub type DefaultMetadata = HashMap<String, String>;
+pub type DefaultLogMessage = LogMessage<DefaultMetadata>;
+pub type DefaultLogMessageBuilder = LogMessageBuilder<DefaultMetadata>;
+
+#[derive(Serialize)]
 pub enum LogMessageId {
     None,
     Other(String),
 }
 
-#[derive(Serialize, Deserialize)]
-pub struct LogMessage {
+#[derive(Serialize)]
+pub struct LogMessage<Metadata: Serialize> {
     id: LogMessageId,
     level: log::Level,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     tags: Vec<String>,
     message: String,
     timestamp: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    metadata: Option<Metadata>,
 }
 
-pub struct LogMessageBuilder {
+pub struct LogMessageBuilder<Metadata: Serialize> {
     id: LogMessageId,
     level: log::Level,
     tags: Vec<String>,
     message: Option<String>,
+    metadata: Option<Metadata>,
 }
 
 impl std::fmt::Display for LogMessageId {
@@ -29,13 +37,14 @@ impl std::fmt::Display for LogMessageId {
     }
 }
 
-impl LogMessageBuilder {
+impl<Metadata: Serialize> LogMessageBuilder<Metadata> {
     pub fn new() -> Self {
         Self {
             id: LogMessageId::None,
             level: log::Level::max(),
             tags: vec![],
             message: None,
+            metadata: None,
         }
     }
 
@@ -45,6 +54,7 @@ impl LogMessageBuilder {
             level: self.level,
             tags: self.tags,
             message: self.message,
+            metadata: self.metadata,
         }
     }
 
@@ -54,15 +64,17 @@ impl LogMessageBuilder {
             level,
             tags: self.tags,
             message: self.message,
+            metadata: self.metadata,
         }
     }
 
-    pub fn with_tags(self, tags: Vec<String>) -> Self {
+    pub fn with_tags(self, tags: Vec<&str>) -> Self {
         Self {
             id: self.id,
             level: self.level,
-            tags,
+            tags: tags.iter().map(|s| s.to_string()).collect(),
             message: self.message,
+            metadata: self.metadata,
         }
     }
 
@@ -72,34 +84,53 @@ impl LogMessageBuilder {
             level: self.level,
             tags: self.tags,
             message: Some(message),
+            metadata: self.metadata,
+        }
+    }
+
+    pub fn with_metadata(self, metadata: Metadata) -> Self {
+        Self {
+            id: self.id,
+            level: self.level,
+            tags: self.tags,
+            message: self.message,
+            metadata: Some(metadata),
         }
     }
 
-    pub fn build(self) -> LogMessage {
+    pub fn build(self) -> LogMessage<Metadata> {
         LogMessage {
             id: self.id,
             level: self.level,
             tags: self.tags,
             message: self.message.unwrap_or_default(),
             timestamp: chrono::Utc::now().timestamp(),
+            metadata: self.metadata,
         }
     }
 }
 
-impl Default for LogMessageBuilder {
+impl<Metadata: Serialize> Default for LogMessageBuilder<Metadata> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl LogMessage {
-    pub fn new(id: LogMessageId, level: log::Level, message: String, tags: Vec<String>) -> Self {
+impl<Metadata: Serialize> LogMessage<Metadata> {
+    pub fn new(
+        id: LogMessageId,
+        level: log::Level,
+        message: String,
+        tags: Vec<String>,
+        metadata: Metadata,
+    ) -> Self {
         Self {
             id,
             level,
             tags,
             message,
             timestamp: chrono::Utc::now().timestamp(),
+            metadata: Some(metadata),
         }
     }
 
@@ -108,7 +139,7 @@ impl LogMessage {
     }
 }
 
-impl std::fmt::Display for LogMessage {
+impl<Metadata: Serialize> std::fmt::Display for LogMessage<Metadata> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", serde_json::to_string(self).unwrap())
     }

logging-lib/src/methods.rs

@@ -3,7 +3,11 @@ macro_rules! log {
     ($lvl:expr, $($arg:tt)+) => (
         let formatted_message = format_args!($($arg)+).to_string();
         let level = $lvl;
-        $crate::messages::LogMessageBuilder::default().with_level(level).with_message(formatted_message).build().log();
+        $crate::messages::DefaultLogMessageBuilder::default()
+            .with_level(level)
+            .with_message(formatted_message)
+            .build()
+            .log();
     )
 }
 

vit-servicing-station-lib/Cargo.toml

@@ -17,6 +17,7 @@ diesel = { version = "1.4.4", features = ["sqlite", "r2d2"] }
 dotenv = "0.9.0"
 itertools = "0.9.0"
 log = { version = "0.4.11", features = ["serde"] }
+logging-lib = { path = "../logging-lib" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.53"
 simplelog = "0.8.0"

vit-servicing-station-lib/src/v0/mod.rs

@@ -4,14 +4,26 @@ pub mod endpoints;
 pub mod errors;
 pub mod result;
 
+use logging_lib::messages::LogMessageId;
 use warp::{Filter, Rejection, Reply};
 
 pub async fn filter(
     ctx: context::SharedContext,
 ) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone {
     let root = warp::path!("api" / "v0" / ..);
 
+    let log = warp::log::custom(|info| {
+        logging_lib::messages::DefaultLogMessageBuilder::new()
+            .with_level(log::Level::Info)
+            .with_tags(vec!["request", "elapsed"])
+            .with_message(format!("{}ns", info.elapsed().as_nanos()))
+            .with_id(LogMessageId::Other("request_average".into()))
+            .build()
+            .log();
+    });
+
     endpoints::filter(root.boxed(), ctx)
         .await
         .recover(errors::handle_rejection)
+        .with(log)
 }