update

Author: erfanium

Cargo.toml

@@ -2,6 +2,9 @@
 name = "fastify-pretty-log"
 version = "0.1.0"
 edition = "2021"
+description = "A simple log formatter for fastify"
+license = "MIT"
+authors = ["Erfan Safari <erfanshield@outlook.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

snap/snapcraft.yaml

@@ -4,7 +4,6 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::io::{self, BufRead};
 use termion::color;
-
 #[derive(Deserialize)]
 struct ReqLog {
     req: Req,
@@ -35,37 +34,20 @@ struct Res {
 }
 
 fn colorize_status_code(status_code: u64) -> String {
-    if status_code >= 500 {
-        format!(
-            "{}{}{}",
-            color::Fg(color::Red),
-            status_code,
-            color::Fg(color::Reset)
-        )
-    } else if status_code >= 400 {
-        format!(
-            "{}{}{}",
-            color::Fg(color::Yellow),
-            status_code,
-            color::Fg(color::Reset)
-        )
-    } else if status_code >= 300 {
-        format!(
-            "{}{}{}",
-            color::Fg(color::Blue),
-            status_code,
-            color::Fg(color::Reset)
-        )
-    } else if status_code >= 200 {
-        format!(
-            "{}{}{}",
-            color::Fg(color::Green),
-            status_code,
-            color::Fg(color::Reset)
-        )
-    } else {
-        status_code.to_string()
-    }
+    let color: Box<dyn color::Color> = match status_code {
+        200 => Box::new(color::Green),
+        300 => Box::new(color::Blue),
+        400 => Box::new(color::Yellow),
+        500 => Box::new(color::Red),
+        _ => Box::new(color::White),
+    };
+
+    format!(
+        "{}{}{}",
+        color::Fg(&*color),
+        status_code,
+        color::Fg(color::Reset)
+    )
 }
 
 fn main() {
@@ -77,63 +59,63 @@ fn main() {
         let value: Result<Value, _> = serde_json::from_str(&line);
 
         if let Ok(value) = value {
-            if let Some(req_id_value) = value.get("reqId") {
-                let req_id = req_id_value.as_str().unwrap().to_string();
-
-                if value.get("req").is_some() {
-                    handle_req_log(value, &req_id, &mut req_logs);
-                } else if value.get("res").is_some() {
-                    handle_res_log(value, &req_id, &mut req_logs);
-                }
-            } else {
-                let message_to_log = match value.get("msg") {
-                    Some(msg) => msg.as_str().unwrap().to_string(),
-                    None => line,
-                };
-
-                println!("{}", message_to_log);
-            }
+            handle_json_line(value, &mut req_logs, line);
         } else {
             println!("{}", line);
         }
     }
 }
 
-fn handle_req_log(value: Value, req_id: &str, req_logs: &mut HashMap<String, ReqLog>) {
-    let log: ReqLog = serde_json::from_value(value).unwrap();
-    req_logs.insert(req_id.to_string(), log);
+fn handle_json_line(value: Value, req_logs: &mut HashMap<String, ReqLog>, raw_line: String) {
+    if let Some(req_id_value) = value.get("reqId") {
+        let req_id = req_id_value.as_str().unwrap().to_string();
+
+        if value.get("req").is_some() {
+            let log: ReqLog = serde_json::from_value(value).unwrap();
+            req_logs.insert(req_id.to_string(), log);
+        } else if value.get("res").is_some() {
+            req_logs.get(&req_id);
+            if let Some(req_log) = req_logs.get(&req_id) {
+                handle_res_log(req_log, value);
+            }
+            req_logs.remove(&req_id);
+        }
+    } else {
+        let message_to_log = match value.get("msg") {
+            Some(msg) => msg.as_str().unwrap().to_string(),
+            None => raw_line,
+        };
+
+        println!("{}", message_to_log);
+    }
 }
 
-fn handle_res_log(value: Value, req_id: &str, req_logs: &mut HashMap<String, ReqLog>) {
+fn handle_res_log(req_log: &ReqLog, value: Value) {
     let log: ResLog = serde_json::from_value(value).unwrap();
-    if let Some(req_log) = req_logs.get(req_id) {
-        let response_time = match log.responseTime {
-            Some(time) => format!("{:.3}ms", time),
-            None => "N/A".to_string(),
-        };
-        let status_code = log.res.statusCode;
+    let response_time = match log.responseTime {
+        Some(time) => format!("{:.3}ms", time),
+        None => "N/A".to_string(),
+    };
+    let status_code = log.res.statusCode;
 
+    if let Some(err) = &log.err {
         println!(
-            "{} {} {} {}",
-            req_log.req.url,
-            req_log.req.method,
-            colorize_status_code(status_code),
-            response_time
+            "{}\n{}",
+            format!(
+                "{}{}{}",
+                color::Fg(color::Red),
+                err.message,
+                color::Fg(color::Reset)
+            ),
+            err.stack
         );
-
-        if let Some(err) = &log.err {
-            println!(
-                "{}\n{}",
-                format!(
-                    "{}{}{}",
-                    color::Fg(color::Red),
-                    err.message,
-                    color::Fg(color::Reset)
-                ),
-                err.stack
-            );
-        }
-
-        req_logs.remove(req_id);
     }
+
+    println!(
+        "{} {} {} {}",
+        req_log.req.url,
+        req_log.req.method,
+        colorize_status_code(status_code),
+        response_time
+    );
 }