http-server-rs · LeoBorai · Dec 16, 2021 · Dec 11, 2021 · Dec 12, 2021
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
@@ -34,3 +34,6 @@ jobs:
 
       - name: "Bench w/ Basic Authentication"
         run: ./scripts/bench.sh '--username "john" --password "appleseed"'
+
+      - name: "Bench w/ Logger"
+        run: ./scripts/bench.sh '--logger'
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -43,6 +43,7 @@ mime_guess = "2.0.3"
 rustls = "0.20.2"
 rustls-pemfile = "0.2.1"
 tokio = { version = "1.14.0", features = ["fs", "rt-multi-thread", "signal", "macros"] }
+termcolor = "1.1.2"
 tokio-rustls = "0.23.1"
 toml = "0.5.8"
 serde = { version = "1.0.131", features = ["derive"] }

diff --git a/src/addon/logger.rs b/src/addon/logger.rs
@@ -0,0 +1,93 @@
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use http::header::USER_AGENT;
+use http::Method;
+use hyper::Body;
+use std::io::Write;
+use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
+
+use crate::server::middleware::{Request, Response};
+
+pub struct Logger {
+    buffer_writer: BufferWriter,
+}
+
+impl Logger {
+    pub fn new() -> Self {
+        let buffer_writer = BufferWriter::stdout(ColorChoice::Always);
+
+        Logger { buffer_writer }
+    }
+
+    pub async fn log(&mut self, request: Request<Body>, response: Response<Body>) -> Result<()> {
+        let mut buffer = self.buffer_writer.buffer();
+        let request = request.lock().await;
+        let response = response.lock().await;
+
+        // UTC Time
+        let moment: DateTime<Utc> = Utc::now();
+        write!(&mut buffer, "[{:?}] \"", moment)?;
+
+        // HTTP Request Method
+        let method = request.method();
+
+        match *method {
+            Method::GET => buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?,
+            Method::POST | Method::PUT | Method::PATCH => {
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Blue)))?
+            }
+            Method::DELETE => buffer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?,
+            _ => buffer.set_color(ColorSpec::new().set_fg(Some(Color::Magenta)))?,
+        };
+
+        write!(&mut buffer, "{} ", method)?;
+        buffer.reset()?;
+
+        // HTTP Request URI and Version
+        write!(&mut buffer, "{} {:?} ", request.uri(), request.version())?;
+
+        // HTTP Response Status Code
+        match response.status().as_u16() {
+            100..=199 => {
+                // Informational Responses
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Blue)))?;
+            }
+            200..=299 => {
+                // Successful responses
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
+            }
+            300..=399 => {
+                // Redirection messages
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))?;
+            }
+            400..=499 => {
+                // Client error responses
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Rgb(255, 140, 0))))?;
+            }
+            500..=599 => {
+                // Server error responses
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Red)))?;
+            }
+            _ => {
+                // Unknown response codes
+                buffer.set_color(ColorSpec::new().set_fg(Some(Color::Magenta)))?;
+            }
+        }
+        write!(&mut buffer, "{}", response.status())?;
+        buffer.reset()?;
+
+        // HTTP Request User Agent
+        let user_agent = if let Some(value) = request.headers().get(USER_AGENT) {
+            value.to_str()?
+        } else {
+            "N/A"
+        };
+        write!(&mut buffer, "\" \"{}\" ", user_agent)?;
+
+        writeln!(&mut buffer)?;
+        self.buffer_writer.print(&buffer)?;
+        buffer.reset()?;
+
+        Ok(())
+    }
+}
diff --git a/src/addon/mod.rs b/src/addon/mod.rs
@@ -1,3 +1,4 @@
 pub mod compression;
 pub mod cors;
 pub mod file_server;
+pub mod logger;
diff --git a/src/cli.rs b/src/cli.rs
@@ -51,6 +51,9 @@ pub struct Cli {
     /// Specifies password for basic authentication
     #[structopt(long = "password")]
     pub password: Option<String>,
+    /// Prints HTTP request and response details to stdout
+    #[structopt(long = "logger")]
+    pub logger: bool,
 }
 
 impl Cli {
@@ -75,6 +78,7 @@ impl Default for Cli {
             gzip: false,
             username: None,
             password: None,
+            logger: false,
         }
     }
 }
@@ -228,4 +232,14 @@ mod tests {
 
         assert_eq!(from_args, expect);
     }
+
+    #[test]
+    fn with_logger() {
+        let from_args = Cli::from_str_args(vec!["http-server", "--logger"]);
+        let mut expect = Cli::default();
+
+        expect.logger = true;
+
+        assert_eq!(from_args, expect);
+    }
 }
diff --git a/src/config/file.rs b/src/config/file.rs
@@ -22,6 +22,7 @@ pub struct ConfigFile {
     pub cors: Option<CorsConfig>,
     pub compression: Option<CompressionConfig>,
     pub basic_auth: Option<BasicAuthConfig>,
+    pub logger: Option<bool>,
 }
 
 impl ConfigFile {
@@ -82,11 +83,12 @@ mod tests {
 
         root_dir.push("./fixtures");
 
+        assert!(config.logger.is_none());
+        assert!(config.compression.is_none());
         assert_eq!(config.host, host);
         assert_eq!(config.port, port);
         assert_eq!(config.verbose, Some(true));
         assert_eq!(config.root_dir, Some(root_dir));
-        assert_eq!(config.compression, None);
     }
 
     #[test]
@@ -279,4 +281,16 @@ mod tests {
         assert_eq!(basic_auth.username, String::from("johnappleseed"));
         assert_eq!(basic_auth.password, String::from("john::likes::apples!"));
     }
+
+    #[test]
+    fn parses_config_with_logger() {
+        let file_contents = r#"
+            host = "0.0.0.0"
+            port = 7878
+            logger = true
+        "#;
+        let config = ConfigFile::parse_toml(file_contents).unwrap();
+
+        assert_eq!(config.logger, Some(true));
+    }
 }
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -30,6 +30,7 @@ pub struct Config {
     cors: Option<CorsConfig>,
     compression: Option<CompressionConfig>,
     basic_auth: Option<BasicAuthConfig>,
+    logger: Option<bool>,
 }
 
 impl Config {
@@ -68,6 +69,10 @@ impl Config {
     pub fn basic_auth(&self) -> Option<BasicAuthConfig> {
         self.basic_auth.clone()
     }
+
+    pub fn logger(&self) -> Option<bool> {
+        self.logger
+    }
 }
 
 impl Default for Config {
@@ -87,6 +92,7 @@ impl Default for Config {
             cors: None,
             compression: None,
             basic_auth: None,
+            logger: None,
         }
     }
 }
@@ -137,6 +143,12 @@ impl TryFrom<Cli> for Config {
                 None
             };
 
+        let logger = if cli_arguments.logger {
+            Some(true)
+        } else {
+            None
+        };
+
         Ok(Config {
             host: cli_arguments.host,
             port: cli_arguments.port,
@@ -147,6 +159,7 @@ impl TryFrom<Cli> for Config {
             cors,
             compression,
             basic_auth,
+            logger,
         })
     }
 }
@@ -177,6 +190,7 @@ impl TryFrom<ConfigFile> for Config {
             cors: file.cors,
             compression: file.compression,
             basic_auth: file.basic_auth,
+            logger: file.logger,
         })
     }
 }

diff --git a/src/server/middleware/logger.rs b/src/server/middleware/logger.rs
@@ -0,0 +1,28 @@
+use http::{Request, Response};
+use hyper::Body;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use crate::addon::logger::Logger;
+
+use super::MiddlewareAfter;
+
+pub fn make_logger_middleware() -> MiddlewareAfter {
+    let logger = Arc::new(Mutex::new(Logger::new()));
+
+    Box::new(
+        move |request: Arc<Mutex<Request<Body>>>, response: Arc<Mutex<Response<Body>>>| {
+            let logger = Arc::clone(&logger);
+
+            Box::pin(async move {
+                let mut logger = logger.lock().await;
+
+                if let Err(error) = logger.log(request, response).await {
+                    eprintln!("{:#?}", error);
+                }
+
+                Ok(())
+            })
+        },
+    )
+}
diff --git a/src/server/middleware/mod.rs b/src/server/middleware/mod.rs
@@ -1,6 +1,7 @@
 pub mod basic_auth;
 pub mod cors;
 pub mod gzip;
+pub mod logger;
 
 use anyhow::Error;
 use futures::Future;
@@ -16,6 +17,7 @@ use crate::config::Config;
 use self::basic_auth::make_basic_auth_middleware;
 use self::cors::make_cors_middleware;
 use self::gzip::make_gzip_compression_middleware;
+use self::logger::make_logger_middleware;
 
 /// Middleware HTTP Response which expands to a `Arc<Mutex<http::Request<T>>>`
 pub type Request<T> = Arc<Mutex<http::Request<T>>>;
@@ -119,6 +121,12 @@ impl TryFrom<Arc<Config>> for Middleware {
             }
         }
 
+        if let Some(should_log) = config.logger() {
+            if should_log {
+                middleware.after(make_logger_middleware());
+            }
+        }
+
         Ok(middleware)
     }
 }