simplify logger builder api.

http/CHANGES.md

@@ -1,6 +1,6 @@
 # unreleased 0.3.0
 ## Change
-- `util::middleware::Logger` does not expect `tracing::Span` anymore. it would make new span per request. `Logger` requires the service type it enclosed with it's `Service::Error` type bound to `std::error::Error` trait instead of `std::fmt::Debug`.
+- `util::middleware::Logger` does not expect `tracing::Span` anymore instead it wants `tracing::Level` for defining the verbosity of span. it would make new span per request with given `Level`. `Logger` middleware requires the service type it enclosed with it's `Service::Error` type bound to `std::error::Error` trait instead of only `std::fmt::Debug`. providing a better tracing output.
 
 # 0.2.2
 ## Change

http/src/util/middleware/logger.rs

@@ -16,13 +16,12 @@ impl Default for Logger {
 impl Logger {
     /// construct a default logger with [`Level::WARN`]
     pub fn new() -> Self {
-        Self { level: Level::WARN }
+        Self::with_level(Level::WARN)
     }
 
-    /// set a logger to given [`Level`]
-    pub fn set_level(mut self, level: Level) -> Self {
-        self.level = level;
-        self
+    /// construct a logger with given [`Level`] verbosity.
+    pub fn with_level(level: Level) -> Self {
+        Self { level } 
     }
 }
 

web/CHANGES.md

@@ -16,7 +16,7 @@
 ## Change
 - change `xitca_web::middleware::eraser::TypeEraser::error`'s trait bound. `From` trait is used for conversion between generic error type and `xitca_web::error::Error`. With this change `Error` does not double boxing itself therefore removing the need of nested type casting when handling typed error.
 - `ErrorStatus::{bad_request, internal}` can't be used in const context anymore as they are tasked with capture thread backtrace.
-- make `xitca_web::middleware::logger` optional crate feature behind `logger` feature flag. extend it's construction with `LoggerBuilder` type which by default bypass manual `tracing-subscriber` import.
+- make `xitca_web::middleware::logger` optional behind `logger` feature flag. extend it's construction which by default bypass manual `tracing-subscriber` import.
 
 # 0.2.2
 ## Add

web/src/middleware/logger.rs

@@ -1,80 +1,56 @@
-use core::marker::PhantomData;
-
-use tracing::Level;
-use xitca_http::util::middleware::Logger;
+use tracing::{warn, Level};
+use xitca_http::util::middleware;
 
 use crate::service::Service;
 
-pub struct LoggerBuilder<S = state::InternalSub> {
-    logger: Logger,
-    _state: PhantomData<S>,
-}
-
-impl<S> LoggerBuilder<S> {
-    fn with_logger(logger: Logger) -> Self {
-        Self {
-            logger,
-            _state: PhantomData,
-        }
-    }
-}
-
-// type state for determine if internal tracing subscriber should be created.
-mod state {
-    pub struct InternalSub;
-    pub struct ExternalSub;
-    pub struct Finalized;
-}
-
-impl Default for LoggerBuilder {
+/// builder for tracing log middleware.
+///
+/// # Examples
+/// ```rust
+/// # use xitca_web::{handler::handler_service, middleware::Logger, route::get, App, WebContext};
+/// App::new()
+///     .at("/", get(handler_service(|| async { "hello,world!" })))
+///     # .at("/infer", handler_service(|_: &WebContext<'_>| async{ "infer type" }))
+///     // log http request and error with default setting.
+///     .enclosed(Logger::new());
+/// ```
+pub struct Logger {
+    logger: middleware::Logger,
+}
+
+impl Default for Logger {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl LoggerBuilder {
+impl Logger {
+    /// construct a new logger middleware builder with [`Level::INFO`] of verbosity it generate and captures.
+    /// would try to initialize global trace dispatcher.
     pub fn new() -> Self {
-        Self {
-            logger: Logger::new(),
-            _state: PhantomData,
-        }
+        Self::with_level(Level::INFO)
     }
 
-    pub fn set_level(mut self, level: Level) -> Self {
-        self.logger = self.logger.set_level(level);
-        self
-    }
-}
-
-impl<S> LoggerBuilder<S> {
-    pub fn external_sub(self) -> LoggerBuilder<state::ExternalSub> {
-        LoggerBuilder::with_logger(self.logger)
-    }
-}
-
-impl LoggerBuilder<state::InternalSub> {
-    /// finalize builder and ready to produce logger middleware service.
-    /// a default tracing subscriber is constructed at the same time.
-    pub fn init(self) -> LoggerBuilder<state::Finalized> {
-        tracing_subscriber::fmt().init();
-        LoggerBuilder::with_logger(self.logger)
-    }
-}
+    /// construct a new logger middleware builder with given [Level] of verbosity it generate and captures.
+    /// would try to initialize global trace dispatcher.
+    pub fn with_level(level: Level) -> Self {
+        if let Err(e) = tracing_subscriber::fmt().with_max_level(level).try_init() {
+            // the most likely case is trace dispatcher has already been set by user. log the warning and move on.
+            warn!("failed to initialize global trace dispatcher: {}", e);
+        }
 
-impl LoggerBuilder<state::ExternalSub> {
-    /// finalize builder and ready to produce logger middleware service.
-    /// no default tracing subscriber would be constructed.
-    pub fn init(self) -> LoggerBuilder<state::Finalized> {
-        LoggerBuilder::with_logger(self.logger)
+        Self {
+            logger: middleware::Logger::with_level(level),
+        }
     }
 }
 
-impl<Arg> Service<Arg> for LoggerBuilder<state::Finalized>
+impl<Arg> Service<Arg> for Logger
 where
-    Logger: Service<Arg>,
+    middleware::Logger: Service<Arg>,
 {
-    type Response = <Logger as Service<Arg>>::Response;
-    type Error = <Logger as Service<Arg>>::Error;
+    type Response = <middleware::Logger as Service<Arg>>::Response;
+    type Error = <middleware::Logger as Service<Arg>>::Error;
 
     async fn call(&self, arg: Arg) -> Result<Self::Response, Self::Error> {
         self.logger.call(arg).await

web/src/middleware/mod.rs

@@ -297,8 +297,6 @@
 pub mod compress;
 #[cfg(any(feature = "compress-br", feature = "compress-gz", feature = "compress-de"))]
 pub mod decompress;
-#[cfg(feature = "logger")]
-pub mod logger;
 #[cfg(feature = "rate-limit")]
 pub mod rate_limit;
 #[cfg(feature = "tower-http-compat")]
@@ -310,6 +308,10 @@ pub mod limit;
 #[cfg(not(target_family = "wasm"))]
 pub mod sync;
 
+#[cfg(feature = "logger")]
+mod logger;
+
+pub use logger::Logger;
 pub use xitca_http::util::middleware::Extension;
 pub use xitca_service::middleware::{Group, UncheckedReady};