Merge pull request #451 from http-rs/log

Adds log submodule

Author: yoshuawuyts

Cargo.toml

@@ -32,7 +32,6 @@ unstable = []
 http-types = "1.0.1"
 http-service = "0.5.0"
 http-service-h1 = { version = "0.1.0", optional = true }
-log = "0.4.8"
 route-recognizer = "0.1.13"
 serde = "1.0.102"
 serde_json = "1.0.41"
@@ -45,6 +44,7 @@ futures = { version = "0.3.1", optional = true }
 http = { version = "0.2.0", optional = true }
 tokio = { version = "0.2.13", optional = true }
 url = "2.1.1"
+kv-log-macro = "1.0.4"
 
 [dev-dependencies]
 async-std = { version = "1.4.0", features = ["unstable", "attributes"] }

examples/static_file.rs

@@ -1,7 +1,8 @@
 use async_std::task;
+use tide::log;
 
 fn main() -> Result<(), std::io::Error> {
-    femme::start(log::LevelFilter::Info).unwrap();
+    femme::start(log::Level::Info.to_level_filter()).unwrap();
     task::block_on(async {
         let mut app = tide::new();
         app.at("/").get(|_| async move { Ok("visit /src/*") });

src/lib.rs

@@ -191,6 +191,7 @@ mod router;
 mod server;
 mod utils;
 
+pub mod log;
 pub mod prelude;
 pub mod redirect;
 

src/middleware/logger.rs renamed to src/log/middleware.rs

@@ -1,27 +1,30 @@
-use crate::{
-    middleware::{Middleware, Next},
-    Request, Response,
-};
+use crate::log;
+use crate::{Middleware, Next, Request, Response};
 use futures_core::future::BoxFuture;
 
-/// A simple requests logger
+/// Log all incoming requests and responses.
 ///
-/// # Examples
+/// This middleware is enabled by default in Tide.
 ///
-/// ```rust
+/// # Examples
 ///
+/// ```
 /// let mut app = tide::Server::new();
-/// app.middleware(tide::middleware::RequestLogger::new());
+/// app.middleware(tide::log::LogMiddleware::new());
 /// ```
-#[derive(Debug, Clone, Default)]
-pub struct RequestLogger;
+#[derive(Debug, Clone)]
+pub struct LogMiddleware {
+    _priv: (),
+}
 
-impl RequestLogger {
+impl LogMiddleware {
+    /// Create a new instance of `LogMiddleware`.
     pub fn new() -> Self {
-        Self::default()
+        Self { _priv: () }
     }
 
-    async fn log_basic<'a, State: Send + Sync + 'static>(
+    /// Log a request and a response.
+    async fn log<'a, State: Send + Sync + 'static>(
         &'a self,
         ctx: Request<State>,
         next: Next<'a, State>,
@@ -57,12 +60,12 @@ impl RequestLogger {
     }
 }
 
-impl<State: Send + Sync + 'static> Middleware<State> for RequestLogger {
+impl<State: Send + Sync + 'static> Middleware<State> for LogMiddleware {
     fn handle<'a>(
         &'a self,
         ctx: Request<State>,
         next: Next<'a, State>,
     ) -> BoxFuture<'a, crate::Result<Response>> {
-        Box::pin(async move { self.log_basic(ctx, next).await })
+        Box::pin(async move { self.log(ctx, next).await })
     }
 }

src/log/mod.rs

@@ -0,0 +1,26 @@
+//! Event logging types.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! use tide::log;
+//!
+//! // `tide::log` requires starting a third-party logger such as `femme`. We may
+//! // ship such a logger as part of Tide in the future.
+//! femme::start(log::Level::Info.to_level_filter()).unwrap();
+//!
+//! log::info!("Hello cats");
+//! log::debug!("{} wants tuna", "Nori");
+//! log::error!("We're out of tuna!");
+//! log::info!("{} are hungry", "cats", {
+//!     cat_1: "Chashu",
+//!     cat_2: "Nori",
+//! });
+//! ```
+
+pub use kv_log_macro::{debug, error, info, log, trace, warn};
+pub use kv_log_macro::{max_level, Level};
+
+mod middleware;
+
+pub use middleware::LogMiddleware;

src/middleware/mod.rs

@@ -14,12 +14,10 @@ use crate::{Request, Response};
 pub(crate) mod cookies;
 mod cors;
 // mod default_headers;
-mod logger;
 
 // pub use compression::{Compression, Decompression};
 pub use cors::{Cors, Origin};
 // pub use default_headers::DefaultHeaders;
-pub use logger::RequestLogger;
 
 /// Middleware that wraps around remaining middleware chain.
 pub trait Middleware<State>: 'static + Send + Sync {

src/server/mod.rs

@@ -10,6 +10,7 @@ use http_service::HttpService;
 use std::fmt::Debug;
 use std::pin::Pin;
 
+use crate::log;
 use crate::middleware::{cookies, Middleware, Next};
 use crate::router::{Router, Selection};
 use crate::utils::BoxFuture;
@@ -205,6 +206,7 @@ impl<State: Send + Sync + 'static> Server<State> {
             state: Arc::new(state),
         };
         server.middleware(cookies::CookiesMiddleware::new());
+        server.middleware(log::LogMiddleware::new());
         server
     }
 

src/server/route.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 
 use super::serve_dir::ServeDir;
 use crate::endpoint::MiddlewareEndpoint;
+use crate::log;
 use crate::utils::BoxFuture;
 use crate::{router::Router, Endpoint, Middleware, Response};
 

src/server/serve_dir.rs

@@ -2,6 +2,7 @@ use async_std::fs::File;
 use async_std::io::BufReader;
 use http_types::{Body, StatusCode};
 
+use crate::log;
 use crate::{Endpoint, Request, Response, Result};
 
 use std::path::{Path, PathBuf};