Add missing fmt::Debug impls (#224)

* Add missing fmt::Debug impls

ntex-connect/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.3.1] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.3.0] - 2023-06-22
 
 * Release v0.3.0

ntex-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-connect"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntexwork connect utils for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -34,13 +34,13 @@ glommio = ["ntex-rt/glommio", "ntex-glommio"]
 async-std = ["ntex-rt/async-std", "ntex-async-std"]
 
 [dependencies]
-ntex-service = "1.2.0"
+ntex-service = "1.2.6"
 ntex-bytes = "0.1.19"
-ntex-http = "0.1.8"
-ntex-io = "0.3.0"
+ntex-http = "0.1.10"
+ntex-io = "0.3.3"
 ntex-rt = "0.4.7"
-ntex-tls = "0.3.0"
-ntex-util = "0.3.0"
+ntex-tls = "0.3.1"
+ntex-util = "0.3.2"
 log = "0.4"
 thiserror = "1.0"
 

ntex-connect/src/lib.rs

@@ -1,4 +1,6 @@
 //! Tcp connector service
+#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
+
 #[macro_use]
 extern crate log;
 

ntex-connect/src/openssl.rs

@@ -1,4 +1,4 @@
-use std::io;
+use std::{fmt, io};
 
 pub use ntex_tls::openssl::SslFilter;
 pub use tls_openssl::ssl::{Error as SslError, HandshakeError, SslConnector, SslMethod};
@@ -88,6 +88,15 @@ impl<T> Clone for Connector<T> {
     }
 }
 
+impl<T> fmt::Debug for Connector<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connector(openssl)")
+            .field("connector", &self.connector)
+            .field("openssl", &self.openssl)
+            .finish()
+    }
+}
+
 impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Connector<T> {
     type Response = Io<Layer<SslFilter>>;
     type Error = ConnectError;

ntex-connect/src/rustls.rs

@@ -1,4 +1,4 @@
-use std::io;
+use std::{fmt, io};
 
 pub use ntex_tls::rustls::TlsFilter;
 pub use tls_rustls::{ClientConfig, ServerName};
@@ -92,6 +92,14 @@ impl<T> Clone for Connector<T> {
     }
 }
 
+impl<T> fmt::Debug for Connector<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connector(rustls)")
+            .field("connector", &self.connector)
+            .finish()
+    }
+}
+
 impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Connector<T> {
     type Response = Io<Layer<TlsFilter>>;
     type Error = ConnectError;

ntex-connect/src/service.rs

@@ -1,5 +1,5 @@
 use std::task::{Context, Poll};
-use std::{collections::VecDeque, future::Future, io, net::SocketAddr, pin::Pin};
+use std::{collections::VecDeque, fmt, future::Future, io, net::SocketAddr, pin::Pin};
 
 use ntex_bytes::{PoolId, PoolRef};
 use ntex_io::{types, Io};
@@ -61,6 +61,15 @@ impl<T> Clone for Connector<T> {
     }
 }
 
+impl<T> fmt::Debug for Connector<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connector")
+            .field("resolver", &self.resolver)
+            .field("memory_pool", &self.pool)
+            .finish()
+    }
+}
+
 impl<T: Address, C: 'static> ServiceFactory<Connect<T>, C> for Connector<T> {
     type Response = Io;
     type Error = ConnectError;
@@ -105,6 +114,14 @@ impl<'f, T: Address> ConnectServiceResponse<'f, T> {
     }
 }
 
+impl<'f, T: Address> fmt::Debug for ConnectServiceResponse<'f, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ConnectServiceResponse")
+            .field("pool", &self.pool)
+            .finish()
+    }
+}
+
 impl<'f, T: Address> Future for ConnectServiceResponse<'f, T> {
     type Output = Result<Io, ConnectError>;
 

ntex-http/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.10] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.1.9] - 2022-12-09
 
 * Add helper method HeaderValue::as_shared()

ntex-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-http"
-version = "0.1.9"
+version = "0.1.10"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Http types for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -20,4 +20,4 @@ http = "0.2"
 log = "0.4"
 fxhash = "0.2.1"
 itoa = "1.0.4"
-ntex-bytes = "0.1.17"
+ntex-bytes = "0.1.19"

ntex-http/src/error.rs

@@ -36,7 +36,7 @@ enum ErrorKind {
 }
 
 impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("ntex_http::Error")
             // Skip the noise of the ErrorKind enum
             .field(&self.get_ref())

ntex-http/src/lib.rs

@@ -1,4 +1,6 @@
 //! Http protocol support.
+#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
+
 pub mod error;
 mod map;
 mod value;

ntex-http/src/map.rs

@@ -62,6 +62,7 @@ impl Value {
     }
 }
 
+#[derive(Debug)]
 pub struct ValueIntoIter {
     value: Value,
 }
@@ -444,6 +445,7 @@ impl TryFrom<&str> for Value {
     }
 }
 
+#[derive(Debug)]
 pub struct GetAll<'a> {
     idx: usize,
     item: Option<&'a Value>,
@@ -477,6 +479,7 @@ impl<'a> Iterator for GetAll<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct Keys<'a>(hash_map::Keys<'a, HeaderName, Value>);
 
 impl<'a> Iterator for Keys<'a> {
@@ -497,6 +500,7 @@ impl<'a> IntoIterator for &'a HeaderMap {
     }
 }
 
+#[derive(Debug)]
 pub struct Iter<'a> {
     idx: usize,
     current: Option<(&'a HeaderName, &'a VecDeque<HeaderValue>)>,

ntex-http/src/value.rs

@@ -512,7 +512,7 @@ fn is_valid(b: u8) -> bool {
 impl Error for InvalidHeaderValue {}
 
 impl fmt::Debug for InvalidHeaderValue {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("InvalidHeaderValue")
             // skip _priv noise
             .finish()

ntex-io/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.3.3] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.3.2] - 2023-08-10
 
 * Replace `PipelineCall` with `ServiceCall<'static, S, R>`

ntex-io/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "0.3.2"
+version = "0.3.3"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -18,8 +18,8 @@ path = "src/lib.rs"
 [dependencies]
 ntex-codec = "0.6.2"
 ntex-bytes = "0.1.19"
-ntex-util = "0.3.0"
-ntex-service = "1.2.3"
+ntex-util = "0.3.2"
+ntex-service = "1.2.6"
 
 bitflags = "1.3"
 log = "0.4"

ntex-io/src/buf.rs

@@ -1,12 +1,29 @@
-use std::cell::Cell;
+use std::{cell::Cell, fmt};
 
 use ntex_bytes::{BytesVec, PoolRef};
 use ntex_util::future::Either;
 
 use crate::IoRef;
 
-type Buffer = (Cell<Option<BytesVec>>, Cell<Option<BytesVec>>);
+#[derive(Default)]
+pub(crate) struct Buffer(Cell<Option<BytesVec>>, Cell<Option<BytesVec>>);
 
+impl fmt::Debug for Buffer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let b0 = self.0.take();
+        let b1 = self.1.take();
+        let res = f
+            .debug_struct("Buffer")
+            .field("0", &b0)
+            .field("1", &b1)
+            .finish();
+        self.0.set(b0);
+        self.1.set(b1);
+        res
+    }
+}
+
+#[derive(Debug)]
 pub struct Stack {
     len: usize,
     buffers: Either<[Buffer; 3], Vec<Buffer>>,
@@ -25,29 +42,32 @@ impl Stack {
             Either::Left(b) => {
                 // move to vec
                 if self.len == 3 {
-                    let mut vec = vec![(Cell::new(None), Cell::new(None))];
+                    let mut vec = vec![Buffer(Cell::new(None), Cell::new(None))];
                     for item in b.iter_mut().take(self.len) {
-                        vec.push((Cell::new(item.0.take()), Cell::new(item.1.take())));
+                        vec.push(Buffer(
+                            Cell::new(item.0.take()),
+                            Cell::new(item.1.take()),
+                        ));
                     }
                     self.len += 1;
                     self.buffers = Either::Right(vec);
                 } else {
                     let mut idx = self.len;
                     while idx > 0 {
-                        let item = (
+                        let item = Buffer(
                             Cell::new(b[idx - 1].0.take()),
                             Cell::new(b[idx - 1].1.take()),
                         );
                         b[idx] = item;
                         idx -= 1;
                     }
-                    b[0] = (Cell::new(None), Cell::new(None));
+                    b[0] = Buffer(Cell::new(None), Cell::new(None));
                     self.len += 1;
                 }
             }
             Either::Right(vec) => {
                 self.len += 1;
-                vec.insert(0, (Cell::new(None), Cell::new(None)));
+                vec.insert(0, Buffer(Cell::new(None), Cell::new(None)));
             }
         }
     }
@@ -65,8 +85,8 @@ impl Stack {
         if self.len > next {
             f(&buffers[idx], &buffers[next])
         } else {
-            let curr = (Cell::new(buffers[idx].0.take()), Cell::new(None));
-            let next = (Cell::new(None), Cell::new(buffers[idx].1.take()));
+            let curr = Buffer(Cell::new(buffers[idx].0.take()), Cell::new(None));
+            let next = Buffer(Cell::new(None), Cell::new(buffers[idx].1.take()));
 
             let result = f(&curr, &next);
             buffers[idx].0.set(curr.0.take());
@@ -265,6 +285,7 @@ impl Stack {
     }
 }
 
+#[derive(Debug)]
 pub struct ReadBuf<'a> {
     pub(crate) io: &'a IoRef,
     pub(crate) curr: &'a Buffer,
@@ -403,6 +424,7 @@ impl<'a> ReadBuf<'a> {
     }
 }
 
+#[derive(Debug)]
 pub struct WriteBuf<'a> {
     pub(crate) io: &'a IoRef,
     pub(crate) curr: &'a Buffer,

ntex-io/src/dispatcher.rs

@@ -44,7 +44,7 @@ where
     pool: Pool,
 }
 
-pub struct DispatcherShared<S, U>
+pub(crate) struct DispatcherShared<S, U>
 where
     S: Service<DispatchItem<U>, Response = Option<Response<U>>>,
     U: Encoder + Decoder,
@@ -64,6 +64,7 @@ enum DispatcherState {
     Shutdown,
 }
 
+#[derive(Debug)]
 enum DispatcherError<S, U> {
     Encoder(U),
     Service(S),

ntex-io/src/filter.rs

@@ -2,6 +2,7 @@ use std::{any, io, task::Context, task::Poll};
 
 use super::{buf::Stack, io::Flags, FilterLayer, IoRef, ReadStatus, WriteStatus};
 
+#[derive(Debug)]
 /// Default `Io` filter
 pub struct Base(IoRef);
 
@@ -11,6 +12,7 @@ impl Base {
     }
 }
 
+#[derive(Debug)]
 pub struct Layer<F, L = Base>(pub(crate) F, L);
 
 impl<F: FilterLayer, L: Filter> Layer<F, L> {

ntex-io/src/io.rs

@@ -153,6 +153,23 @@ impl Drop for IoState {
     }
 }
 
+impl fmt::Debug for IoState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let err = self.error.take();
+        let res = f
+            .debug_struct("IoState")
+            .field("flags", &self.flags)
+            .field("pool", &self.pool)
+            .field("disconnect_timeout", &self.disconnect_timeout)
+            .field("error", &err)
+            .field("buffer", &self.buffer)
+            .field("keepalive", &self.keepalive)
+            .finish();
+        self.error.set(err);
+        res
+    }
+}
+
 impl Io {
     #[inline]
     /// Create `Io` instance
@@ -601,9 +618,7 @@ impl<F> hash::Hash for Io<F> {
 
 impl<F> fmt::Debug for Io<F> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Io")
-            .field("open", &!self.is_closed())
-            .finish()
+        f.debug_struct("Io").field("state", &self.0).finish()
     }
 }
 
@@ -771,6 +786,7 @@ impl<F: Filter> FilterItem<F> {
     }
 }
 
+#[derive(Debug)]
 /// OnDisconnect future resolves when socket get disconnected
 #[must_use = "OnDisconnect do nothing unless polled"]
 pub struct OnDisconnect {

ntex-io/src/ioref.rs

@@ -236,7 +236,7 @@ impl hash::Hash for IoRef {
 impl fmt::Debug for IoRef {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("IoRef")
-            .field("open", &!self.is_closed())
+            .field("state", self.0.as_ref())
             .finish()
     }
 }
@@ -269,8 +269,8 @@ mod tests {
         let msg = state.recv(&BytesCodec).await.unwrap().unwrap();
         assert_eq!(msg, Bytes::from_static(BIN));
         assert_eq!(state.get_ref(), state.as_ref().clone());
-        assert_eq!(format!("{:?}", state), "Io { open: true }");
-        assert_eq!(format!("{:?}", state.get_ref()), "IoRef { open: true }");
+        assert!(format!("{:?}", state).find("Io {").is_some());
+        assert!(format!("{:?}", state.get_ref()).find("IoRef {").is_some());
 
         let res = poll_fn(|cx| Poll::Ready(state.poll_recv(&BytesCodec, cx))).await;
         assert!(res.is_pending());

ntex-io/src/lib.rs

@@ -1,4 +1,6 @@
 //! Utilities for abstructing io streams
+#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
+
 use std::{
     any::Any, any::TypeId, fmt, future::Future, io as sio, io::Error as IoError,
     task::Context, task::Poll,

ntex-io/src/seal.rs

@@ -1,10 +1,16 @@
-use std::ops;
+use std::{fmt, ops};
 
 use crate::{filter::Filter, Io};
 
 /// Sealed filter type
 pub struct Sealed(pub(crate) Box<dyn Filter>);
 
+impl fmt::Debug for Sealed {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Sealed").finish()
+    }
+}
+
 #[derive(Debug)]
 /// Boxed `Io` object with erased filter type
 pub struct IoBoxed(Io<Sealed>);

ntex-io/src/tasks.rs

@@ -4,6 +4,7 @@ use ntex_bytes::{BytesVec, PoolRef};
 
 use super::{io::Flags, IoRef, ReadStatus, WriteStatus};
 
+#[derive(Debug)]
 /// Context for io read task
 pub struct ReadContext(IoRef);
 
@@ -97,6 +98,7 @@ impl ReadContext {
     }
 }
 
+#[derive(Debug)]
 /// Context for io write task
 pub struct WriteContext(IoRef);
 

ntex-io/src/types.rs

@@ -65,3 +65,13 @@ impl<T: any::Any> QueryItem<T> {
         }
     }
 }
+
+impl<T: any::Any + fmt::Debug> fmt::Debug for QueryItem<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(v) = self.as_ref() {
+            f.debug_tuple("QueryItem").field(v).finish()
+        } else {
+            f.debug_tuple("QueryItem").field(&None::<T>).finish()
+        }
+    }
+}

ntex-io/src/utils.rs

@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use std::{fmt, marker::PhantomData};
 
 use ntex_service::{chain_factory, fn_service, Service, ServiceCtx, ServiceFactory};
 use ntex_util::future::Ready;
@@ -41,6 +41,14 @@ pub struct FilterServiceFactory<T, F> {
     _t: PhantomData<F>,
 }
 
+impl<T: FilterFactory<F> + fmt::Debug, F> fmt::Debug for FilterServiceFactory<T, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FilterServiceFactory")
+            .field("filter_factory", &self.filter)
+            .finish()
+    }
+}
+
 impl<T, F> ServiceFactory<Io<F>> for FilterServiceFactory<T, F>
 where
     T: FilterFactory<F> + Clone,
@@ -65,6 +73,14 @@ pub struct FilterService<T, F> {
     _t: PhantomData<F>,
 }
 
+impl<T: FilterFactory<F> + fmt::Debug, F> fmt::Debug for FilterService<T, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FilterService")
+            .field("filter_factory", &self.filter)
+            .finish()
+    }
+}
+
 impl<T, F> Service<Io<F>> for FilterService<T, F>
 where
     T: FilterFactory<F> + Clone,

ntex-service/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.2.6] - 2023-09-11
+
+* Add fmt::Debug impls
+
 ## [1.2.5] - 2023-08-14
 
 * Use Pipeline<T> instead of ApplyService<T>

ntex-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-service"
-version = "1.2.5"
+version = "1.2.6"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex service"
 keywords = ["network", "framework", "async", "futures"]

ntex-service/src/and_then.rs

@@ -2,6 +2,7 @@ use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
+#[derive(Clone, Debug)]
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
 ///
@@ -18,19 +19,6 @@ impl<A, B> AndThen<A, B> {
     }
 }
 
-impl<A, B> Clone for AndThen<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        AndThen {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 impl<A, B, Req> Service<Req> for AndThen<A, B>
 where
     A: Service<Req>,
@@ -129,6 +117,7 @@ where
     }
 }
 
+#[derive(Debug, Clone)]
 /// `.and_then()` service factory combinator
 pub struct AndThenFactory<A, B> {
     svc1: A,
@@ -166,19 +155,6 @@ where
     }
 }
 
-impl<A, B> Clone for AndThenFactory<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 pin_project_lite::pin_project! {
     #[must_use = "futures do nothing unless polled"]
     pub struct AndThenFactoryResponse<'f, A, B, Req, Cfg>

ntex-service/src/apply.rs

@@ -1,5 +1,5 @@
 #![allow(clippy::type_complexity)]
-use std::{future::Future, marker, pin::Pin, task, task::Poll};
+use std::{fmt, future::Future, marker, pin::Pin, task, task::Poll};
 
 use super::ctx::ServiceCtx;
 use super::{IntoService, IntoServiceFactory, Pipeline, Service, ServiceFactory};
@@ -72,6 +72,18 @@ where
     }
 }
 
+impl<T, Req, F, R, In, Out, Err> fmt::Debug for Apply<T, Req, F, R, In, Out, Err>
+where
+    T: Service<Req, Error = Err> + fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Apply")
+            .field("service", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<T, Req, F, R, In, Out, Err> Service<In> for Apply<T, Req, F, R, In, Out, Err>
 where
     T: Service<Req, Error = Err>,
@@ -135,6 +147,21 @@ where
     }
 }
 
+impl<T, Req, Cfg, F, R, In, Out, Err> fmt::Debug
+    for ApplyFactory<T, Req, Cfg, F, R, In, Out, Err>
+where
+    T: ServiceFactory<Req, Cfg, Error = Err> + fmt::Debug,
+    F: Fn(In, Pipeline<T::Service>) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ApplyFactory")
+            .field("factory", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<T, Req, Cfg, F, R, In, Out, Err> ServiceFactory<In, Cfg>
     for ApplyFactory<T, Req, Cfg, F, R, In, Out, Err>
 where
@@ -208,7 +235,7 @@ mod tests {
     use super::*;
     use crate::{chain, chain_factory, Service, ServiceCtx};
 
-    #[derive(Clone)]
+    #[derive(Clone, Debug)]
     struct Srv;
 
     impl Service<()> for Srv {
@@ -258,6 +285,7 @@ mod tests {
         let res = srv.call("srv").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", ()));
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -280,6 +308,7 @@ mod tests {
         let res = srv.call("srv").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", ()));
+        format!("{:?}", new_srv);
     }
 
     #[ntex::test]
@@ -298,5 +327,6 @@ mod tests {
         let res = srv.call("srv").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv", ()));
+        format!("{:?}", new_srv);
     }
 }

ntex-service/src/boxed.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, pin::Pin, task::Context, task::Poll};
 
 use crate::ctx::{ServiceCtx, WaitersRef};
 
@@ -32,6 +32,20 @@ where
     BoxService(Box::new(service))
 }
 
+impl<Req, Res, Err> fmt::Debug for BoxService<Req, Res, Err> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BoxService").finish()
+    }
+}
+
+impl<Cfg, Req, Res, Err, InitErr> fmt::Debug
+    for BoxServiceFactory<Cfg, Req, Res, Err, InitErr>
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BoxServiceFactory").finish()
+    }
+}
+
 trait ServiceObj<Req> {
     type Response;
     type Error;

ntex-service/src/chain.rs

@@ -1,5 +1,5 @@
 #![allow(clippy::type_complexity)]
-use std::{future::Future, marker::PhantomData};
+use std::{fmt, future::Future, marker::PhantomData};
 
 use crate::and_then::{AndThen, AndThenFactory};
 use crate::apply::{Apply, ApplyFactory};
@@ -156,6 +156,17 @@ where
     }
 }
 
+impl<Svc, Req> fmt::Debug for ServiceChain<Svc, Req>
+where
+    Svc: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ServiceChain")
+            .field("service", &self.service)
+            .finish()
+    }
+}
+
 impl<Svc: Service<Req>, Req> Service<Req> for ServiceChain<Svc, Req> {
     type Response = Svc::Response;
     type Error = Svc::Error;
@@ -315,6 +326,17 @@ where
     }
 }
 
+impl<T, R, C> fmt::Debug for ServiceChainFactory<T, R, C>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ServiceChainFactory")
+            .field("factory", &self.factory)
+            .finish()
+    }
+}
+
 impl<T: ServiceFactory<R, C>, R, C> ServiceFactory<R, C> for ServiceChainFactory<T, R, C> {
     type Response = T::Response;
     type Error = T::Error;

ntex-service/src/ctx.rs

@@ -1,4 +1,4 @@
-use std::{cell::UnsafeCell, future::Future, marker, pin::Pin, rc::Rc, task};
+use std::{cell::UnsafeCell, fmt, future::Future, marker, pin::Pin, rc::Rc, task};
 
 use crate::{Pipeline, Service};
 
@@ -75,6 +75,15 @@ impl Clone for Waiters {
     }
 }
 
+impl fmt::Debug for Waiters {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Waiters")
+            .field("index", &self.index)
+            .field("waiters", &self.waiters.get().len())
+            .finish()
+    }
+}
+
 impl Drop for Waiters {
     #[inline]
     fn drop(&mut self) {
@@ -148,6 +157,15 @@ impl<'a, S> Clone for ServiceCtx<'a, S> {
     }
 }
 
+impl<'a, S> fmt::Debug for ServiceCtx<'a, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ServiceCtx")
+            .field("idx", &self.idx)
+            .field("waiters", &self.waiters.get().len())
+            .finish()
+    }
+}
+
 pin_project_lite::pin_project! {
     #[must_use = "futures do nothing unless polled"]
     pub struct ServiceCall<'a, S, Req>

ntex-service/src/fn_service.rs

@@ -1,4 +1,4 @@
-use std::{future::ready, future::Future, future::Ready, marker::PhantomData};
+use std::{fmt, future::ready, future::Future, future::Ready, marker::PhantomData};
 
 use crate::{IntoService, IntoServiceFactory, Service, ServiceCtx, ServiceFactory};
 
@@ -118,6 +118,14 @@ where
     }
 }
 
+impl<F, Req> fmt::Debug for FnService<F, Req> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnService")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Req>
 where
     F: Fn(Req) -> Fut,
@@ -180,6 +188,18 @@ where
     }
 }
 
+impl<F, Fut, Req, Res, Err, Cfg> fmt::Debug for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+where
+    F: Fn(Req) -> Fut,
+    Fut: Future<Output = Result<Res, Err>>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnServiceFactory")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
     F: Fn(Req) -> Fut,
@@ -255,6 +275,19 @@ where
     }
 }
 
+impl<F, Fut, Cfg, Srv, Req, Err> fmt::Debug for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
+where
+    F: Fn(Cfg) -> Fut,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service<Req>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnServiceConfig")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req, Cfg>
     for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
@@ -328,6 +361,19 @@ where
     }
 }
 
+impl<F, S, R, Req, E> fmt::Debug for FnServiceNoConfig<F, S, R, Req, E>
+where
+    F: Fn() -> R,
+    R: Future<Output = Result<S, E>>,
+    S: Service<Req>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnServiceNoConfig")
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<F, S, R, Req, E, C> IntoServiceFactory<FnServiceNoConfig<F, S, R, Req, E>, Req, C>
     for F
 where
@@ -353,17 +399,20 @@ mod tests {
     #[ntex::test]
     async fn test_fn_service() {
         let new_srv = fn_service(|()| async { Ok::<_, ()>("srv") }).clone();
+        format!("{:?}", new_srv);
 
         let srv = Pipeline::new(new_srv.create(()).await.unwrap());
         let res = srv.call(()).await;
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), "srv");
+        format!("{:?}", srv);
 
         let srv2 = Pipeline::new(new_srv.clone());
         let res = srv2.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), "srv");
+        format!("{:?}", srv2);
 
         assert_eq!(lazy(|cx| srv2.poll_shutdown(cx)).await, Poll::Ready(()));
     }

ntex-service/src/fn_shutdown.rs

@@ -1,7 +1,5 @@
-use std::cell::Cell;
-use std::future::{ready, Ready};
-use std::marker::PhantomData;
 use std::task::{Context, Poll};
+use std::{cell::Cell, fmt, future::ready, future::Ready, marker::PhantomData};
 
 use crate::{Service, ServiceCtx};
 
@@ -43,6 +41,14 @@ where
     }
 }
 
+impl<Req, Err, F> fmt::Debug for FnShutdown<Req, Err, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FnShutdown")
+            .field("fn", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<Req, Err, F> Service<Req> for FnShutdown<Req, Err, F>
 where
     F: FnOnce(),
@@ -91,5 +97,7 @@ mod tests {
         assert_eq!(res.unwrap(), "pipe");
         assert_eq!(lazy(|cx| pipe.poll_shutdown(cx)).await, Poll::Ready(()));
         assert!(is_called.get());
+
+        format!("{:?}", pipe);
     }
 }

ntex-service/src/lib.rs

@@ -1,6 +1,10 @@
 //! See [`Service`] docs for information on this crate's foundational trait.
-
-#![deny(rust_2018_idioms, warnings)]
+#![deny(
+    rust_2018_idioms,
+    warnings,
+    unreachable_pub,
+    missing_debug_implementations
+)]
 
 use std::future::Future;
 use std::rc::Rc;

ntex-service/src/map.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
@@ -41,6 +41,18 @@ where
     }
 }
 
+impl<A, F, Req, Res> fmt::Debug for Map<A, F, Req, Res>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Map")
+            .field("service", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, F, Req, Res> Service<Req> for Map<A, F, Req, Res>
 where
     A: Service<Req>,
@@ -133,6 +145,18 @@ where
     }
 }
 
+impl<A, F, Req, Res, Cfg> fmt::Debug for MapFactory<A, F, Req, Res, Cfg>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapFactory")
+            .field("factory", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, F, Req, Res, Cfg> ServiceFactory<Req, Cfg> for MapFactory<A, F, Req, Res, Cfg>
 where
     A: ServiceFactory<Req, Cfg>,
@@ -194,7 +218,7 @@ mod tests {
     use super::*;
     use crate::{fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Srv;
 
     impl Service<()> for Srv {
@@ -223,6 +247,8 @@ mod tests {
 
         let res = lazy(|cx| srv.poll_shutdown(cx)).await;
         assert_eq!(res, Poll::Ready(()));
+
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -248,6 +274,8 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("ok"));
+
+        format!("{:?}", new_srv);
     }
 
     #[ntex::test]
@@ -259,5 +287,7 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("ok"));
+
+        format!("{:?}", new_srv);
     }
 }

ntex-service/src/map_config.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::{IntoServiceFactory, ServiceFactory};
 
@@ -56,6 +56,18 @@ where
     }
 }
 
+impl<A, F, C, C2> fmt::Debug for MapConfig<A, F, C, C2>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapConfig")
+            .field("factory", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, F, R, C, C2> ServiceFactory<R, C> for MapConfig<A, F, C, C2>
 where
     A: ServiceFactory<R, C2>,
@@ -74,24 +86,16 @@ where
     }
 }
 
+#[derive(Clone, Debug)]
 /// `unit_config()` config combinator
 pub struct UnitConfig<A> {
-    a: A,
+    factory: A,
 }
 
 impl<A> UnitConfig<A> {
     /// Create new `UnitConfig` combinator
-    pub(crate) fn new(a: A) -> Self {
-        Self { a }
-    }
-}
-
-impl<A> Clone for UnitConfig<A>
-where
-    A: Clone,
-{
-    fn clone(&self) -> Self {
-        Self { a: self.a.clone() }
+    pub(crate) fn new(factory: A) -> Self {
+        Self { factory }
     }
 }
 
@@ -108,7 +112,7 @@ where
 
     fn create(&self, _: C) -> Self::Future<'_> {
         UnitConfigFuture {
-            fut: self.a.create(()),
+            fut: self.factory.create(()),
             _t: PhantomData,
         }
     }
@@ -161,6 +165,7 @@ mod tests {
 
         let _ = factory.create(&10).await;
         assert_eq!(item.get(), 11);
+        format!("{:?}", factory);
     }
 
     #[ntex::test]

ntex-service/src/map_err.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
@@ -42,6 +42,18 @@ where
     }
 }
 
+impl<A, F, E> fmt::Debug for MapErr<A, F, E>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapErr")
+            .field("svc", &self.service)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, R, F, E> Service<R> for MapErr<A, F, E>
 where
     A: Service<R>,
@@ -138,6 +150,19 @@ where
     }
 }
 
+impl<A, R, C, F, E> fmt::Debug for MapErrFactory<A, R, C, F, E>
+where
+    A: ServiceFactory<R, C> + fmt::Debug,
+    F: Fn(A::Error) -> E + Clone,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapErrFactory")
+            .field("factory", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, R, C, F, E> ServiceFactory<R, C> for MapErrFactory<A, R, C, F, E>
 where
     A: ServiceFactory<R, C>,
@@ -198,7 +223,7 @@ mod tests {
     use super::*;
     use crate::{fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Srv(bool);
 
     impl Service<()> for Srv {
@@ -235,6 +260,8 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -243,6 +270,8 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+
+        format!("{:?}", srv);
     }
 
     #[ntex::test]
@@ -254,6 +283,7 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+        format!("{:?}", new_srv);
     }
 
     #[ntex::test]
@@ -266,5 +296,6 @@ mod tests {
         let res = srv.call(()).await;
         assert!(res.is_err());
         assert_eq!(res.err().unwrap(), "error");
+        format!("{:?}", new_srv);
     }
 }

ntex-service/src/map_init_err.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use super::ServiceFactory;
 
@@ -38,6 +38,18 @@ where
     }
 }
 
+impl<A, R, C, F, E> fmt::Debug for MapInitErr<A, R, C, F, E>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapInitErr")
+            .field("service", &self.a)
+            .field("map", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<A, R, C, F, E> ServiceFactory<R, C> for MapInitErr<A, R, C, F, E>
 where
     A: ServiceFactory<R, C>,
@@ -108,6 +120,7 @@ mod tests {
 
         assert!(factory.create(&true).await.is_err());
         assert!(factory.create(&false).await.is_ok());
+        format!("{:?}", factory);
     }
 
     #[ntex::test]
@@ -127,5 +140,6 @@ mod tests {
 
         assert!(factory.create(&true).await.is_err());
         assert!(factory.create(&false).await.is_ok());
+        format!("{:?}", factory);
     }
 }

ntex-service/src/middleware.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker, pin::Pin, rc::Rc, task::Context, task::Poll};
+use std::{fmt, future::Future, marker, pin::Pin, rc::Rc, task::Context, task::Poll};
 
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
@@ -113,6 +113,19 @@ impl<T, S, C> Clone for ApplyMiddleware<T, S, C> {
     }
 }
 
+impl<T, S, C> fmt::Debug for ApplyMiddleware<T, S, C>
+where
+    T: fmt::Debug,
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ApplyMiddleware")
+            .field("service", &self.0 .1)
+            .field("middleware", &self.0 .0)
+            .finish()
+    }
+}
+
 impl<T, S, R, C> ServiceFactory<R, C> for ApplyMiddleware<T, S, C>
 where
     S: ServiceFactory<R, C>,
@@ -216,7 +229,7 @@ mod tests {
     use super::*;
     use crate::{fn_service, Pipeline, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Tr<R>(marker::PhantomData<R>);
 
     impl<S, R> Middleware<S> for Tr<R> {
@@ -227,7 +240,7 @@ mod tests {
         }
     }
 
-    #[derive(Clone)]
+    #[derive(Debug, Clone)]
     struct Srv<S, R>(S, marker::PhantomData<R>);
 
     impl<S: Service<R>, R> Service<R> for Srv<S, R> {
@@ -256,6 +269,7 @@ mod tests {
         let res = srv.call(10).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), 20);
+        format!("{:?} {:?}", factory, srv);
 
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Ok(())));
@@ -272,6 +286,7 @@ mod tests {
         let res = srv.call(10).await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), 20);
+        format!("{:?} {:?}", factory, srv);
 
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Ok(())));

ntex-service/src/pipeline.rs

@@ -2,6 +2,7 @@ use std::{cell::Cell, future, pin::Pin, rc::Rc, task, task::Context, task::Poll}
 
 use crate::{ctx::ServiceCall, ctx::Waiters, Service, ServiceCtx, ServiceFactory};
 
+#[derive(Debug)]
 /// Container for a service.
 ///
 /// Container allows to call enclosed service and adds support of shared readiness.

ntex-service/src/then.rs

@@ -2,6 +2,7 @@ use std::{future::Future, pin::Pin, task::Context, task::Poll};
 
 use super::{Service, ServiceCall, ServiceCtx, ServiceFactory};
 
+#[derive(Debug, Clone)]
 /// Service for the `then` combinator, chaining a computation onto the end of
 /// another service.
 ///
@@ -18,19 +19,6 @@ impl<A, B> Then<A, B> {
     }
 }
 
-impl<A, B> Clone for Then<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Then {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 impl<A, B, R> Service<R> for Then<A, B>
 where
     A: Service<R>,
@@ -131,6 +119,7 @@ where
     }
 }
 
+#[derive(Debug, Clone)]
 /// `.then()` service factory combinator
 pub struct ThenFactory<A, B> {
     svc1: A,
@@ -172,19 +161,6 @@ where
     }
 }
 
-impl<A, B> Clone for ThenFactory<A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            svc1: self.svc1.clone(),
-            svc2: self.svc2.clone(),
-        }
-    }
-}
-
 pin_project_lite::pin_project! {
     #[must_use = "futures do nothing unless polled"]
     pub struct ThenFactoryResponse<'f, A, B, R, C>

ntex-tls/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.3.1] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.3.0] - 2023-06-22
 
 * Release v0.3.0

ntex-tls/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-tls"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "An implementation of SSL streams for ntex backed by OpenSSL"
 keywords = ["network", "framework", "async", "futures"]
@@ -26,9 +26,9 @@ rustls = ["tls_rust"]
 
 [dependencies]
 ntex-bytes = "0.1.19"
-ntex-io = "0.3.0"
-ntex-util = "0.3.0"
-ntex-service = "1.2.0"
+ntex-io = "0.3.3"
+ntex-util = "0.3.2"
+ntex-service = "1.2.6"
 log = "0.4"
 pin-project-lite = "0.2"
 

ntex-tls/src/counter.rs

@@ -3,12 +3,13 @@ use std::{cell::Cell, rc::Rc, task};
 
 use ntex_util::task::LocalWaker;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 /// Simple counter with ability to notify task on reaching specific number
 ///
 /// Counter could be cloned, total count is shared across all clones.
 pub(super) struct Counter(Rc<CounterInner>);
 
+#[derive(Debug)]
 struct CounterInner {
     count: Cell<usize>,
     capacity: usize,
@@ -17,7 +18,7 @@ struct CounterInner {
 
 impl Counter {
     /// Create `Counter` instance and set max value.
-    pub fn new(capacity: usize) -> Self {
+    pub(super) fn new(capacity: usize) -> Self {
         Counter(Rc::new(CounterInner {
             capacity,
             count: Cell::new(0),
@@ -26,13 +27,13 @@ impl Counter {
     }
 
     /// Get counter guard.
-    pub fn get(&self) -> CounterGuard {
+    pub(super) fn get(&self) -> CounterGuard {
         CounterGuard::new(self.0.clone())
     }
 
     /// Check if counter is not at capacity. If counter at capacity
     /// it registers notification for current task.
-    pub fn available(&self, cx: &mut task::Context<'_>) -> bool {
+    pub(super) fn available(&self, cx: &mut task::Context<'_>) -> bool {
         self.0.available(cx)
     }
 }

ntex-tls/src/lib.rs

@@ -1,4 +1,6 @@
 //! An implementations of SSL streams for ntex ecosystem
+#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 #[doc(hidden)]

ntex-tls/src/openssl/accept.rs

@@ -11,6 +11,7 @@ use crate::MAX_SSL_ACCEPT_COUNTER;
 
 use super::{SslAcceptor as IoSslAcceptor, SslFilter};
 
+#[derive(Debug)]
 /// Support `TLS` server connections via openssl package
 ///
 /// `openssl` feature enables `Acceptor` type
@@ -71,6 +72,7 @@ impl<F: Filter, C: 'static> ServiceFactory<Io<F>, C> for Acceptor<F> {
     }
 }
 
+#[derive(Debug)]
 /// Support `TLS` server connections via openssl package
 ///
 /// `openssl` feature enables `Acceptor` type

ntex-tls/src/openssl/mod.rs

@@ -1,6 +1,6 @@
 //! An implementation of SSL streams for ntex backed by OpenSSL
 use std::cell::{Cell, RefCell};
-use std::{any, cmp, error::Error, io, task::Context, task::Poll};
+use std::{any, cmp, error::Error, fmt, io, task::Context, task::Poll};
 
 use ntex_bytes::{BufMut, BytesVec};
 use ntex_io::{types, Filter, FilterFactory, FilterLayer, Io, Layer, ReadBuf, WriteBuf};
@@ -22,11 +22,13 @@ pub struct PeerCert(pub X509);
 pub struct PeerCertChain(pub Vec<X509>);
 
 /// An implementation of SSL streams
+#[derive(Debug)]
 pub struct SslFilter {
     inner: RefCell<SslStream<IoInner>>,
     handshake: Cell<bool>,
 }
 
+#[derive(Debug)]
 struct IoInner {
     source: Option<BytesVec>,
     destination: Option<BytesVec>,
@@ -242,6 +244,14 @@ impl Clone for SslAcceptor {
     }
 }
 
+impl fmt::Debug for SslAcceptor {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SslAcceptor")
+            .field("timeout", &self.timeout)
+            .finish()
+    }
+}
+
 impl<F: Filter> FilterFactory<F> for SslAcceptor {
     type Filter = SslFilter;
 
@@ -292,6 +302,7 @@ impl<F: Filter> FilterFactory<F> for SslAcceptor {
     }
 }
 
+#[derive(Debug)]
 pub struct SslConnector {
     ssl: ssl::Ssl,
 }

ntex-tls/src/rustls/accept.rs

@@ -10,6 +10,7 @@ use ntex_util::{future::Ready, time::Millis};
 use super::{TlsAcceptor, TlsFilter};
 use crate::{counter::Counter, counter::CounterGuard, MAX_SSL_ACCEPT_COUNTER};
 
+#[derive(Debug)]
 /// Support `SSL` connections via rustls package
 ///
 /// `rust-tls` feature enables `RustlsAcceptor` type
@@ -71,6 +72,7 @@ impl<F: Filter, C: 'static> ServiceFactory<Io<F>, C> for Acceptor<F> {
     }
 }
 
+#[derive(Debug)]
 /// RusTLS based `Acceptor` service
 pub struct AcceptorService<F> {
     acceptor: TlsAcceptor,

ntex-tls/src/rustls/client.rs

@@ -11,8 +11,9 @@ use crate::rustls::{IoInner, TlsFilter, Wrapper};
 
 use super::{PeerCert, PeerCertChain};
 
+#[derive(Debug)]
 /// An implementation of SSL streams
-pub struct TlsClientFilter {
+pub(crate) struct TlsClientFilter {
     inner: IoInner,
     session: RefCell<ClientConnection>,
 }

ntex-tls/src/rustls/mod.rs

@@ -25,11 +25,13 @@ pub struct PeerCert(pub Certificate);
 #[derive(Debug)]
 pub struct PeerCertChain(pub Vec<Certificate>);
 
+#[derive(Debug)]
 /// An implementation of SSL streams
 pub struct TlsFilter {
     inner: InnerTlsFilter,
 }
 
+#[derive(Debug)]
 enum InnerTlsFilter {
     Server(TlsServerFilter),
     Client(TlsClientFilter),
@@ -110,6 +112,7 @@ impl FilterLayer for TlsFilter {
     }
 }
 
+#[derive(Debug)]
 pub struct TlsAcceptor {
     cfg: Arc<ServerConfig>,
     timeout: Millis,
@@ -162,6 +165,7 @@ impl<F: Filter> FilterFactory<F> for TlsAcceptor {
     }
 }
 
+#[derive(Debug)]
 pub struct TlsConnector {
     cfg: Arc<ClientConfig>,
 }
@@ -189,6 +193,7 @@ impl Clone for TlsConnector {
     }
 }
 
+#[derive(Debug)]
 pub struct TlsConnectorConfigured {
     cfg: Arc<ClientConfig>,
     server_name: ServerName,
@@ -217,6 +222,7 @@ impl<F: Filter> FilterFactory<F> for TlsConnectorConfigured {
     }
 }
 
+#[derive(Debug)]
 pub(crate) struct IoInner {
     handshake: Cell<bool>,
 }

ntex-tls/src/rustls/server.rs

@@ -12,8 +12,9 @@ use crate::Servername;
 
 use super::{PeerCert, PeerCertChain};
 
+#[derive(Debug)]
 /// An implementation of SSL streams
-pub struct TlsServerFilter {
+pub(crate) struct TlsServerFilter {
     inner: IoInner,
     session: RefCell<ServerConnection>,
 }

ntex-util/CHANGES.md

@@ -1,8 +1,12 @@
 # Changes
 
+## [0.3.2] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.3.1] - 2023-06-24
 
-* Changed `BufferService` to maintain order 
+* Changed `BufferService` to maintain order
 
 * Buffer error type changed to indicate cancellation
 

ntex-util/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-util"
-version = "0.3.1"
+version = "0.3.2"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,7 +17,7 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-rt = "0.4.7"
-ntex-service = "1.2.2"
+ntex-service = "1.2.6"
 bitflags = "1.3"
 fxhash = "0.2.1"
 log = "0.4"

ntex-util/src/channel/cell.rs

@@ -46,6 +46,7 @@ impl<T> Cell<T> {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct WeakCell<T> {
     inner: Weak<UnsafeCell<T>>,
 }

ntex-util/src/channel/condition.rs

@@ -5,9 +5,10 @@ use super::cell::Cell;
 use crate::{future::poll_fn, task::LocalWaker};
 
 /// Condition allows to notify multiple waiters at the same time
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Condition(Cell<Inner>);
 
+#[derive(Debug)]
 struct Inner {
     data: Slab<Option<LocalWaker>>,
 }
@@ -50,6 +51,7 @@ impl Drop for Condition {
     }
 }
 
+#[derive(Debug)]
 #[must_use = "Waiter do nothing unless polled"]
 pub struct Waiter {
     token: usize,

ntex-util/src/channel/mpsc.rs

@@ -124,6 +124,7 @@ impl<T> Drop for Sender<T> {
     }
 }
 
+#[derive(Debug)]
 /// Weak sender type
 pub struct WeakSender<T> {
     shared: WeakCell<Shared<T>>,

ntex-util/src/lib.rs

@@ -1,4 +1,6 @@
 //! Utilities for ntex framework
+#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
+
 pub mod channel;
 pub mod future;
 pub mod services;

ntex-util/src/services/buffer.rs

@@ -1,7 +1,7 @@
 //! Service that buffers incomming requests.
 use std::cell::{Cell, RefCell};
 use std::task::{ready, Context, Poll};
-use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin};
+use std::{collections::VecDeque, fmt, future::Future, marker::PhantomData, pin::Pin};
 
 use ntex_service::{IntoService, Middleware, Service, ServiceCallToCall, ServiceCtx};
 
@@ -16,16 +16,6 @@ pub struct Buffer<R> {
     _t: PhantomData<R>,
 }
 
-impl<R> Default for Buffer<R> {
-    fn default() -> Self {
-        Self {
-            buf_size: 16,
-            cancel_on_shutdown: false,
-            _t: PhantomData,
-        }
-    }
-}
-
 impl<R> Buffer<R> {
     pub fn buf_size(mut self, size: usize) -> Self {
         self.buf_size = size;
@@ -41,6 +31,25 @@ impl<R> Buffer<R> {
     }
 }
 
+impl<R> Default for Buffer<R> {
+    fn default() -> Self {
+        Self {
+            buf_size: 16,
+            cancel_on_shutdown: false,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<R> fmt::Debug for Buffer<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Buffer")
+            .field("buf_size", &self.buf_size)
+            .field("cancel_on_shutdown", &self.cancel_on_shutdown)
+            .finish()
+    }
+}
+
 impl<R> Clone for Buffer<R> {
     fn clone(&self) -> Self {
         Self {
@@ -127,6 +136,22 @@ where
     }
 }
 
+impl<R, S> fmt::Debug for BufferService<R, S>
+where
+    S: Service<R> + fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BufferService")
+            .field("size", &self.size)
+            .field("cancel_on_shutdown", &self.cancel_on_shutdown)
+            .field("ready", &self.ready)
+            .field("service", &self.service)
+            .field("buf", &self.buf)
+            .field("next_call", &self.next_call)
+            .finish()
+    }
+}
+
 impl<R, S> Service<R> for BufferService<R, S>
 where
     S: Service<R>,

ntex-util/src/services/counter.rs

@@ -5,8 +5,10 @@ use crate::task::LocalWaker;
 /// Simple counter with ability to notify task on reaching specific number
 ///
 /// Counter could be cloned, total count is shared across all clones.
+#[derive(Debug)]
 pub struct Counter(Rc<CounterInner>);
 
+#[derive(Debug)]
 struct CounterInner {
     count: Cell<usize>,
     capacity: usize,
@@ -40,6 +42,7 @@ impl Counter {
     }
 }
 
+#[derive(Debug)]
 pub struct CounterGuard(Rc<CounterInner>);
 
 impl CounterGuard {

ntex-util/src/services/inflight.rs

@@ -37,6 +37,7 @@ impl<S> Middleware<S> for InFlight {
     }
 }
 
+#[derive(Debug)]
 pub struct InFlightService<S> {
     count: Counter,
     service: S,

ntex-util/src/services/keepalive.rs

@@ -1,5 +1,5 @@
 use std::task::{Context, Poll};
-use std::{cell::Cell, convert::Infallible, marker, time::Duration, time::Instant};
+use std::{cell::Cell, convert::Infallible, fmt, marker, time::Duration, time::Instant};
 
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
 
@@ -45,6 +45,15 @@ where
     }
 }
 
+impl<R, E, F> fmt::Debug for KeepAlive<R, E, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("KeepAlive")
+            .field("ka", &self.ka)
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<R, E, F, C: 'static> ServiceFactory<R, C> for KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
@@ -86,6 +95,16 @@ where
     }
 }
 
+impl<R, E, F> fmt::Debug for KeepAliveService<R, E, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("KeepAliveService")
+            .field("dur", &self.dur)
+            .field("expire", &self.expire)
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,

ntex-util/src/services/onerequest.rs

@@ -22,6 +22,7 @@ impl<S> Middleware<S> for OneRequest {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct OneRequestService<S> {
     waker: LocalWaker,
     service: S,

ntex-util/src/services/variant.rs

@@ -1,5 +1,5 @@
 //! Contains `Variant` service and related types and functions.
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use ntex_service::{IntoServiceFactory, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
@@ -46,6 +46,17 @@ where
     }
 }
 
+impl<A, AR, AC> fmt::Debug for Variant<A, AR, AC>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Variant")
+            .field("V1", &self.factory)
+            .finish()
+    }
+}
+
 macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident, $r_name:ident, $m_name:ident, ($($T:ident),+), ($($R:ident),+)} => {
 
     #[allow(non_snake_case)]
@@ -73,7 +84,7 @@ macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident,
 
 macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident, $fac_type:ident, $(($n:tt, $T:ident, $R:ident)),+} => {
 
-    #[allow(non_snake_case)]
+    #[allow(non_snake_case, missing_debug_implementations)]
     pub enum $enum_type<V1R, $($R),+> {
         V1(V1R),
         $($T($R),)+
@@ -96,6 +107,15 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
         }
     }
 
+    impl<V1: fmt::Debug, $($T: fmt::Debug,)+ V1R, $($R,)+> fmt::Debug for $srv_type<V1, $($T,)+ V1R, $($R,)+> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct(stringify!($srv_type))
+                .field("V1", &self.V1)
+                $(.field(stringify!($T), &self.$T))+
+                .finish()
+        }
+    }
+
     impl<V1, $($T,)+ V1R, $($R,)+> Service<$enum_type<V1R, $($R,)+>> for $srv_type<V1, $($T,)+ V1R, $($R,)+>
     where
         V1: Service<V1R>,
@@ -154,6 +174,15 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
         }
     }
 
+    impl<V1: fmt::Debug, V1C, $($T: fmt::Debug,)+ V1R, $($R,)+> fmt::Debug for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct(stringify!(fac_type))
+                .field("V1", &self.V1)
+                $(.field(stringify!($T), &self.$T))+
+                .finish()
+        }
+    }
+
     impl<V1, V1C, $($T,)+ V1R, $($R,)+> ServiceFactory<$enum_type<V1R, $($R),+>, V1C> for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+>
     where
         V1: ServiceFactory<V1R, V1C>,

ntex-util/src/task.rs

@@ -58,6 +58,12 @@ impl LocalWaker {
     }
 }
 
+impl Clone for LocalWaker {
+    fn clone(&self) -> Self {
+        LocalWaker::new()
+    }
+}
+
 impl fmt::Debug for LocalWaker {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "LocalWaker")

ntex/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.7.4] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.7.3] - 2023-08-10
 
 * Update ntex-service

ntex/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex"
-version = "0.7.3"
+version = "0.7.4"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Framework for composable network services"
 readme = "README.md"
@@ -49,17 +49,17 @@ async-std = ["ntex-rt/async-std", "ntex-async-std", "ntex-connect/async-std"]
 
 [dependencies]
 ntex-codec = "0.6.2"
-ntex-connect = "0.3.0"
-ntex-http = "0.1.9"
+ntex-connect = "0.3.1"
+ntex-http = "0.1.10"
 ntex-router = "0.5.1"
-ntex-service = "1.2.5"
+ntex-service = "1.2.6"
 ntex-macros = "0.1.3"
-ntex-util = "0.3.0"
+ntex-util = "0.3.2"
 ntex-bytes = "0.1.19"
 ntex-h2 = "0.3.2"
 ntex-rt = "0.4.9"
-ntex-io = "0.3.2"
-ntex-tls = "0.3.0"
+ntex-io = "0.3.3"
+ntex-tls = "0.3.1"
 ntex-tokio = { version = "0.3.0", optional = true }
 ntex-glommio = { version = "0.3.0", optional = true }
 ntex-async-std = { version = "0.3.0", optional = true }

ntex/src/http/client/builder.rs

@@ -14,6 +14,7 @@ use super::{Client, ClientConfig, Connect, Connection, Connector};
 ///
 /// This type can be used to construct an instance of `Client` through a
 /// builder-like pattern.
+#[derive(Debug)]
 pub struct ClientBuilder {
     config: ClientConfig,
     default_headers: bool,
@@ -44,7 +45,9 @@ impl ClientBuilder {
     /// Use custom connector service.
     pub fn connector<T>(mut self, connector: T) -> Self
     where
-        T: Service<Connect, Response = Connection, Error = ConnectError> + 'static,
+        T: Service<Connect, Response = Connection, Error = ConnectError>
+            + fmt::Debug
+            + 'static,
     {
         self.config.connector = Box::new(ConnectorWrapper(connector.into()));
         self

ntex/src/http/client/connect.rs

@@ -1,4 +1,4 @@
-use std::net;
+use std::{fmt, net};
 
 use crate::http::{body::Body, RequestHeadType};
 use crate::{service::Pipeline, service::Service, util::BoxFuture};
@@ -7,9 +7,21 @@ use super::error::{ConnectError, SendRequestError};
 use super::response::ClientResponse;
 use super::{Connect as ClientConnect, Connection};
 
+// #[derive(Debug)]
 pub(super) struct ConnectorWrapper<T>(pub(crate) Pipeline<T>);
 
-pub(super) trait Connect {
+impl<T> fmt::Debug for ConnectorWrapper<T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connector")
+            .field("service", &self.0)
+            .finish()
+    }
+}
+
+pub(super) trait Connect: fmt::Debug {
     fn send_request(
         &self,
         head: RequestHeadType,
@@ -20,7 +32,7 @@ pub(super) trait Connect {
 
 impl<T> Connect for ConnectorWrapper<T>
 where
-    T: Service<ClientConnect, Response = Connection, Error = ConnectError>,
+    T: Service<ClientConnect, Response = Connection, Error = ConnectError> + fmt::Debug,
 {
     fn send_request(
         &self,

ntex/src/http/client/connector.rs

@@ -1,4 +1,4 @@
-use std::{task::Context, task::Poll, time::Duration};
+use std::{fmt, task::Context, task::Poll, time::Duration};
 
 use ntex_h2::{self as h2};
 
@@ -18,6 +18,7 @@ use crate::connect::rustls::ClientConfig;
 
 type BoxedConnector = boxed::BoxService<TcpConnect<Uri>, IoBoxed, ConnectError>;
 
+#[derive(Debug)]
 /// Manages http client network connectivity.
 ///
 /// The `Connector` type uses a builder-like combinator pattern for service
@@ -222,7 +223,8 @@ impl Connector {
     /// its combinator chain.
     pub fn finish(
         self,
-    ) -> impl Service<Connect, Response = Connection, Error = ConnectError> {
+    ) -> impl Service<Connect, Response = Connection, Error = ConnectError> + fmt::Debug
+    {
         let tcp_service = connector(self.connector, self.timeout, self.disconnect_timeout);
 
         let ssl_pool = if let Some(ssl_connector) = self.ssl_connector {
@@ -257,7 +259,7 @@ fn connector(
     connector: BoxedConnector,
     timeout: Millis,
     disconnect_timeout: Millis,
-) -> impl Service<Connect, Response = IoBoxed, Error = ConnectError> {
+) -> impl Service<Connect, Response = IoBoxed, Error = ConnectError> + fmt::Debug {
     TimeoutService::new(
         timeout,
         apply_fn(connector, |msg: Connect, srv| {
@@ -278,6 +280,7 @@ fn connector(
     })
 }
 
+#[derive(Debug)]
 struct InnerConnector<T> {
     tcp_pool: ConnectionPool<T>,
     ssl_pool: Option<ConnectionPool<T>>,

ntex/src/http/client/frozen.rs

@@ -135,6 +135,7 @@ impl fmt::Debug for FrozenClientRequest {
 }
 
 /// Builder that allows to modify extra headers.
+#[derive(Debug)]
 pub struct FrozenSendBuilder {
     req: FrozenClientRequest,
     extra_headers: HeaderMap,

ntex/src/http/client/mod.rs

@@ -47,7 +47,7 @@ use crate::time::Millis;
 
 use self::connect::{Connect as HttpConnect, ConnectorWrapper};
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Connect {
     pub uri: Uri,
     pub addr: Option<std::net::SocketAddr>,
@@ -70,9 +70,10 @@ pub struct Connect {
 ///      println!("Response: {:?}", res);
 /// }
 /// ```
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Client(Rc<ClientConfig>);
 
+#[derive(Debug)]
 struct ClientConfig {
     pub(self) connector: Box<dyn HttpConnect>,
     pub(self) headers: HeaderMap,

ntex/src/http/client/pool.rs

@@ -43,6 +43,7 @@ struct AvailableConnection {
 }
 
 /// Connections pool
+#[derive(Debug)]
 pub(super) struct ConnectionPool<T> {
     connector: Pipeline<T>,
     inner: Rc<RefCell<Inner>>,
@@ -174,6 +175,7 @@ where
     }
 }
 
+#[derive(Debug)]
 pub(super) struct Inner {
     conn_lifetime: Duration,
     conn_keep_alive: Duration,
@@ -187,6 +189,7 @@ pub(super) struct Inner {
     waiters: Rc<RefCell<Waiters>>,
 }
 
+#[derive(Debug)]
 struct Waiters {
     waiters: HashMap<Key, VecDeque<(Connect, Waiter)>>,
     pool: pool::Pool<Result<Connection, ConnectError>>,

ntex/src/http/client/response.rs

@@ -166,6 +166,7 @@ impl fmt::Debug for ClientResponse {
     }
 }
 
+#[derive(Debug)]
 /// Future that resolves to a complete http message body.
 pub struct MessageBody {
     length: Option<usize>,
@@ -244,6 +245,7 @@ impl Future for MessageBody {
     }
 }
 
+#[derive(Debug)]
 /// Response's payload json parser, it resolves to a deserialized `T` value.
 ///
 /// Returns error:
@@ -342,6 +344,7 @@ where
     }
 }
 
+#[derive(Debug)]
 struct ReadBody {
     stream: Payload,
     buf: BytesMut,

ntex/src/http/client/test.rs

@@ -9,6 +9,7 @@ use crate::util::Bytes;
 
 use super::ClientResponse;
 
+#[derive(Debug)]
 /// Test `ClientResponse` builder
 pub struct TestResponse {
     head: ResponseHead,

ntex/src/http/config.rs

@@ -40,9 +40,11 @@ impl From<Option<usize>> for KeepAlive {
     }
 }
 
+#[derive(Debug)]
 /// Http service configuration
 pub struct ServiceConfig(pub(super) Rc<Inner>);
 
+#[derive(Debug)]
 pub(super) struct Inner {
     pub(super) keep_alive: Millis,
     pub(super) client_timeout: Millis,

ntex/src/http/encoding/encoder.rs

@@ -1,5 +1,5 @@
 //! Stream encoder
-use std::{future::Future, io, io::Write, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, io, io::Write, pin::Pin, task::Context, task::Poll};
 
 use brotli2::write::BrotliEncoder;
 use flate2::write::{GzEncoder, ZlibEncoder};
@@ -14,6 +14,7 @@ use super::Writer;
 
 const INPLACE: usize = 1024;
 
+#[derive(Debug)]
 pub struct Encoder<B> {
     eof: bool,
     body: EncoderBody<B>,
@@ -67,6 +68,16 @@ enum EncoderBody<B> {
     BoxedStream(Box<dyn MessageBody>),
 }
 
+impl<B> fmt::Debug for EncoderBody<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            EncoderBody::Bytes(ref b) => write!(f, "EncoderBody::Bytes({:?})", b),
+            EncoderBody::Stream(_) => write!(f, "EncoderBody::Stream(_)"),
+            EncoderBody::BoxedStream(_) => write!(f, "EncoderBody::BoxedStream(_)"),
+        }
+    }
+}
+
 impl<B: MessageBody> MessageBody for Encoder<B> {
     fn size(&self) -> BodySize {
         if self.encoder.is_none() {
@@ -248,3 +259,13 @@ impl ContentEncoder {
         }
     }
 }
+
+impl fmt::Debug for ContentEncoder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ContentEncoder::Deflate(_) => write!(f, "ContentEncoder::Deflate"),
+            ContentEncoder::Gzip(_) => write!(f, "ContentEncoder::Gzip"),
+            ContentEncoder::Br(_) => write!(f, "ContentEncoder::Br"),
+        }
+    }
+}

ntex/src/http/h1/expect.rs

@@ -3,6 +3,7 @@ use std::io;
 use crate::service::{Service, ServiceCtx, ServiceFactory};
 use crate::{http::request::Request, util::Ready};
 
+#[derive(Copy, Clone, Debug)]
 pub struct ExpectHandler;
 
 impl ServiceFactory<Request> for ExpectHandler {

ntex/src/http/h1/payload.rs

@@ -83,6 +83,7 @@ impl Stream for Payload {
 }
 
 /// Sender part of the payload stream
+#[derive(Debug)]
 pub struct PayloadSender {
     inner: Weak<RefCell<Inner>>,
 }

ntex/src/http/response.rs

@@ -242,6 +242,7 @@ impl<B: MessageBody> fmt::Debug for Response<B> {
 }
 
 #[cfg(feature = "cookie")]
+#[derive(Debug)]
 pub struct CookieIter<'a> {
     iter: header::GetAll<'a>,
 }

ntex/src/http/test.rs

@@ -15,6 +15,7 @@ use super::header::{self, HeaderMap, HeaderName, HeaderValue};
 use super::payload::Payload;
 use super::{Method, Request, Uri, Version};
 
+#[derive(Debug)]
 /// Test `Request` builder
 ///
 /// ```rust,no_run
@@ -39,6 +40,7 @@ use super::{Method, Request, Uri, Version};
 /// ```
 pub struct TestRequest(Option<Inner>);
 
+#[derive(Debug)]
 struct Inner {
     version: Version,
     method: Method,
@@ -276,6 +278,7 @@ where
     }
 }
 
+#[derive(Debug)]
 /// Test server controller
 pub struct TestServer {
     addr: net::SocketAddr,

ntex/src/lib.rs

@@ -9,7 +9,7 @@
 #![warn(
     rust_2018_idioms,
     unreachable_pub,
-    // missing_debug_implementations,
+    missing_debug_implementations,
     // missing_docs,
 )]
 #![allow(

ntex/src/server/accept.rs

@@ -1,4 +1,6 @@
-use std::{cell::Cell, io, sync::mpsc, sync::Arc, thread, time::Duration, time::Instant};
+use std::{
+    cell::Cell, fmt, io, sync::mpsc, sync::Arc, thread, time::Duration, time::Instant,
+};
 
 use polling::{Event, Poller};
 
@@ -22,6 +24,7 @@ pub(super) enum Command {
     WorkerAvailable,
 }
 
+#[derive(Debug)]
 struct ServerSocketInfo {
     addr: SocketAddr,
     token: Token,
@@ -107,6 +110,16 @@ impl AcceptLoop {
     }
 }
 
+impl fmt::Debug for AcceptLoop {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AcceptLoop")
+            .field("notify", &self.notify)
+            .field("inner", &self.inner)
+            .field("status_handler", &self.status_handler.is_some())
+            .finish()
+    }
+}
+
 struct Accept {
     poller: Arc<Poller>,
     rx: mpsc::Receiver<Command>,

ntex/src/server/config.rs

@@ -11,9 +11,10 @@ use super::service::{
 };
 use super::{builder::bind_addr, counter::CounterGuard, Token};
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Config(Rc<InnerServiceConfig>);
 
+#[derive(Debug)]
 pub(super) struct InnerServiceConfig {
     pub(super) pool: Cell<PoolId>,
 }

ntex/src/server/test.rs

@@ -92,6 +92,7 @@ where
     }
 }
 
+#[derive(Debug)]
 /// Test server controller
 pub struct TestServer {
     addr: net::SocketAddr,

ntex/src/web/error_default.rs

@@ -15,7 +15,7 @@ use super::error::{self, ErrorContainer, ErrorRenderer, WebResponseError};
 use super::{HttpRequest, HttpResponse};
 
 /// Default error type
-#[derive(Clone, Copy, Default)]
+#[derive(Clone, Copy, Default, Debug)]
 pub struct DefaultError;
 
 impl ErrorRenderer for DefaultError {

ntex/src/web/guard.rs

@@ -27,6 +27,8 @@
 //! ```
 #![allow(non_snake_case)]
 
+use std::fmt;
+
 use crate::http::{header, Method, RequestHead, Uri};
 
 /// Trait defines resource guards. Guards are used for route selection.
@@ -37,6 +39,11 @@ use crate::http::{header, Method, RequestHead, Uri};
 pub trait Guard {
     /// Check if request matches predicate
     fn check(&self, request: &RequestHead) -> bool;
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Guard").finish()
+    }
 }
 
 /// Create guard object for supplied function.
@@ -71,6 +78,13 @@ where
     fn check(&self, head: &RequestHead) -> bool {
         (self.0)(head)
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("FnGuard")
+            .field(&std::any::type_name::<F>())
+            .finish()
+    }
 }
 
 impl<F> Guard for F
@@ -99,8 +113,9 @@ pub fn Any<F: Guard + 'static>(guard: F) -> AnyGuard {
     AnyGuard(vec![Box::new(guard)])
 }
 
+#[derive(Default)]
 /// Matches if any of supplied guards matche.
-pub struct AnyGuard(Vec<Box<dyn Guard>>);
+pub struct AnyGuard(pub Vec<Box<dyn Guard>>);
 
 impl AnyGuard {
     /// Add guard to a list of guards to check
@@ -119,6 +134,21 @@ impl Guard for AnyGuard {
         }
         false
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "AnyGuard(")?;
+        self.0.iter().for_each(|t| {
+            let _ = t.fmt(f);
+        });
+        write!(f, ")")
+    }
+}
+
+impl fmt::Debug for AnyGuard {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Guard::fmt(self, f)
+    }
 }
 
 /// Return guard that matches if all of the supplied guards.
@@ -139,8 +169,9 @@ pub fn All<F: Guard + 'static>(guard: F) -> AllGuard {
     AllGuard(vec![Box::new(guard)])
 }
 
+#[derive(Default)]
 /// Matches if all of supplied guards.
-pub struct AllGuard(Vec<Box<dyn Guard>>);
+pub struct AllGuard(pub(super) Vec<Box<dyn Guard>>);
 
 impl AllGuard {
     /// Add new guard to the list of guards to check
@@ -148,6 +179,11 @@ impl AllGuard {
         self.0.push(Box::new(guard));
         self
     }
+
+    /// Add guard to a list of guards to check
+    pub fn add<F: Guard + 'static>(&mut self, guard: F) {
+        self.0.push(Box::new(guard));
+    }
 }
 
 impl Guard for AllGuard {
@@ -159,6 +195,21 @@ impl Guard for AllGuard {
         }
         true
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "AllGuard(")?;
+        self.0.iter().for_each(|t| {
+            let _ = t.fmt(f);
+        });
+        write!(f, ")")
+    }
+}
+
+impl fmt::Debug for AllGuard {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Guard::fmt(self, f)
+    }
 }
 
 /// Return guard that matches if supplied guard does not match.
@@ -173,16 +224,35 @@ impl Guard for NotGuard {
     fn check(&self, request: &RequestHead) -> bool {
         !self.0.check(request)
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "NotGuard(")?;
+        self.0.fmt(f)?;
+        write!(f, ")")
+    }
+}
+
+impl fmt::Debug for NotGuard {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Guard::fmt(self, f)
+    }
 }
 
 /// Http method guard
 #[doc(hidden)]
+#[derive(Debug)]
 pub struct MethodGuard(Method);
 
 impl Guard for MethodGuard {
     fn check(&self, request: &RequestHead) -> bool {
         request.method == self.0
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
 }
 
 /// Guard to match *GET* http method
@@ -245,6 +315,7 @@ pub fn Header(name: &'static str, value: &'static str) -> HeaderGuard {
 }
 
 #[doc(hidden)]
+#[derive(Debug)]
 pub struct HeaderGuard(header::HeaderName, header::HeaderValue);
 
 impl Guard for HeaderGuard {
@@ -254,6 +325,11 @@ impl Guard for HeaderGuard {
         }
         false
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
 }
 
 /// Return predicate that matches if request contains specified Host name.
@@ -284,6 +360,7 @@ fn get_host_uri(req: &RequestHead) -> Option<Uri> {
 }
 
 #[doc(hidden)]
+#[derive(Debug)]
 pub struct HostGuard(String, Option<String>);
 
 impl HostGuard {
@@ -318,6 +395,11 @@ impl Guard for HostGuard {
 
         true
     }
+
+    /// Debug format
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
 }
 
 #[cfg(test)]

ntex/src/web/handler.rs

@@ -1,4 +1,4 @@
-use std::{future::Future, marker::PhantomData};
+use std::{fmt, future::Future, marker::PhantomData};
 
 use crate::util::BoxFuture;
 
@@ -36,7 +36,7 @@ where
     }
 }
 
-pub(super) trait HandlerFn<Err: ErrorRenderer> {
+pub(super) trait HandlerFn<Err: ErrorRenderer>: fmt::Debug {
     fn call(
         &self,
         _: WebRequest<Err>,
@@ -57,6 +57,12 @@ impl<F, T, Err> HandlerWrapper<F, T, Err> {
     }
 }
 
+impl<F, T, Err> fmt::Debug for HandlerWrapper<F, T, Err> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Handler({:?})", std::any::type_name::<F>())
+    }
+}
+
 impl<F, T, Err> HandlerFn<Err> for HandlerWrapper<F, T, Err>
 where
     F: Handler<T, Err> + 'static,

ntex/src/web/middleware/compress.rs

@@ -54,6 +54,7 @@ impl<S> Middleware<S> for Compress {
     }
 }
 
+#[derive(Debug)]
 pub struct CompressMiddleware<S> {
     service: S,
     encoding: ContentEncoding,

ntex/src/web/middleware/defaultheaders.rs

@@ -25,11 +25,12 @@ use crate::web::{WebRequest, WebResponse};
 ///         );
 /// }
 /// ```
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct DefaultHeaders {
     inner: Rc<Inner>,
 }
 
+#[derive(Debug)]
 struct Inner {
     ct: bool,
     headers: HeaderMap,
@@ -97,6 +98,7 @@ impl<S> Middleware<S> for DefaultHeaders {
     }
 }
 
+#[derive(Debug)]
 pub struct DefaultHeadersMiddleware<S> {
     service: S,
     inner: Rc<Inner>,

ntex/src/web/middleware/logger.rs

@@ -67,10 +67,12 @@ use crate::web::{HttpResponse, WebRequest, WebResponse};
 ///
 /// `%{FOO}e`  os.environ['FOO']
 ///
+#[derive(Debug)]
 pub struct Logger {
     inner: Rc<Inner>,
 }
 
+#[derive(Debug)]
 struct Inner {
     format: Format,
     exclude: HashSet<String>,
@@ -124,6 +126,7 @@ impl<S> Middleware<S> for Logger {
     }
 }
 
+#[derive(Debug)]
 /// Logger middleware
 pub struct LoggerMiddleware<S> {
     inner: Rc<Inner>,
@@ -251,7 +254,7 @@ impl MessageBody for StreamLog {
 
 /// A formatting style for the `Logger`, consisting of multiple
 /// `FormatText`s concatenated into one line.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 #[doc(hidden)]
 struct Format(Vec<FormatText>);
 

ntex/src/web/route.rs

@@ -1,4 +1,4 @@
-use std::{mem, rc::Rc};
+use std::{fmt, mem, rc::Rc};
 
 use crate::util::{BoxFuture, Ready};
 use crate::{http::Method, service::Service, service::ServiceCtx, service::ServiceFactory};
@@ -6,7 +6,7 @@ use crate::{http::Method, service::Service, service::ServiceCtx, service::Servic
 use super::error::ErrorRenderer;
 use super::error_default::DefaultError;
 use super::extract::FromRequest;
-use super::guard::{self, Guard};
+use super::guard::{self, AllGuard, Guard};
 use super::handler::{Handler, HandlerFn, HandlerWrapper};
 use super::request::WebRequest;
 use super::response::WebResponse;
@@ -19,7 +19,7 @@ use super::HttpResponse;
 pub struct Route<Err: ErrorRenderer = DefaultError> {
     handler: Rc<dyn HandlerFn<Err>>,
     methods: Vec<Method>,
-    guards: Rc<Vec<Box<dyn Guard>>>,
+    guards: Rc<AllGuard>,
 }
 
 impl<Err: ErrorRenderer> Route<Err> {
@@ -28,7 +28,7 @@ impl<Err: ErrorRenderer> Route<Err> {
         Route {
             handler: Rc::new(HandlerWrapper::new(|| async { HttpResponse::NotFound() })),
             methods: Vec::new(),
-            guards: Rc::new(Vec::new()),
+            guards: Default::default(),
         }
     }
 
@@ -36,10 +36,10 @@ impl<Err: ErrorRenderer> Route<Err> {
         for m in &self.methods {
             Rc::get_mut(&mut self.guards)
                 .unwrap()
-                .push(Box::new(guard::Method(m.clone())));
+                .add(guard::Method(m.clone()));
         }
 
-        mem::take(Rc::get_mut(&mut self.guards).unwrap())
+        mem::take(&mut Rc::get_mut(&mut self.guards).unwrap().0)
     }
 
     pub(super) fn service(&self) -> RouteService<Err> {
@@ -51,6 +51,16 @@ impl<Err: ErrorRenderer> Route<Err> {
     }
 }
 
+impl<Err: ErrorRenderer> fmt::Debug for Route<Err> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Route")
+            .field("handler", &self.handler)
+            .field("methods", &self.methods)
+            .field("guards", &self.guards)
+            .finish()
+    }
+}
+
 impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err> {
     type Response = WebResponse;
     type Error = Err::Container;
@@ -66,7 +76,7 @@ impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err> {
 pub struct RouteService<Err: ErrorRenderer> {
     handler: Rc<dyn HandlerFn<Err>>,
     methods: Vec<Method>,
-    guards: Rc<Vec<Box<dyn Guard>>>,
+    guards: Rc<AllGuard>,
 }
 
 impl<Err: ErrorRenderer> RouteService<Err> {
@@ -75,12 +85,17 @@ impl<Err: ErrorRenderer> RouteService<Err> {
             return false;
         }
 
-        for f in self.guards.iter() {
-            if !f.check(req.head()) {
-                return false;
-            }
-        }
-        true
+        self.guards.check(req.head())
+    }
+}
+
+impl<Err: ErrorRenderer> fmt::Debug for RouteService<Err> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RouteService")
+            .field("handler", &self.handler)
+            .field("methods", &self.methods)
+            .field("guards", &self.guards)
+            .finish()
     }
 }
 
@@ -132,7 +147,7 @@ impl<Err: ErrorRenderer> Route<Err> {
     /// # }
     /// ```
     pub fn guard<F: Guard + 'static>(mut self, f: F) -> Self {
-        Rc::get_mut(&mut self.guards).unwrap().push(Box::new(f));
+        Rc::get_mut(&mut self.guards).unwrap().add(f);
         self
     }
 

ntex/src/web/service.rs

@@ -7,7 +7,7 @@ use crate::util::Extensions;
 use super::config::AppConfig;
 use super::dev::insert_slash;
 use super::error::ErrorRenderer;
-use super::guard::Guard;
+use super::guard::{AllGuard, Guard};
 use super::{request::WebRequest, response::WebResponse, rmap::ResourceMap};
 
 pub trait WebServiceFactory<Err: ErrorRenderer> {
@@ -194,10 +194,11 @@ impl<Err: ErrorRenderer> WebServiceConfig<Err> {
 ///         .finish(my_service)
 /// );
 /// ```
+#[derive(Debug)]
 pub struct WebServiceAdapter {
     rdef: Vec<String>,
     name: Option<String>,
-    guards: Vec<Box<dyn Guard>>,
+    guards: AllGuard,
 }
 
 impl WebServiceAdapter {
@@ -206,7 +207,7 @@ impl WebServiceAdapter {
         WebServiceAdapter {
             rdef: path.patterns(),
             name: None,
-            guards: Vec::new(),
+            guards: Default::default(),
         }
     }
 
@@ -237,7 +238,7 @@ impl WebServiceAdapter {
     /// }
     /// ```
     pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
-        self.guards.push(Box::new(guard));
+        self.guards.add(guard);
         self
     }
 
@@ -266,7 +267,7 @@ struct WebServiceImpl<T> {
     srv: T,
     rdef: Vec<String>,
     name: Option<String>,
-    guards: Vec<Box<dyn Guard>>,
+    guards: AllGuard,
 }
 
 impl<T, Err> WebServiceFactory<Err> for WebServiceImpl<T>
@@ -280,10 +281,10 @@ where
     Err: ErrorRenderer,
 {
     fn register(mut self, config: &mut WebServiceConfig<Err>) {
-        let guards = if self.guards.is_empty() {
+        let guards = if self.guards.0.is_empty() {
             None
         } else {
-            Some(std::mem::take(&mut self.guards))
+            Some(std::mem::take(&mut self.guards.0))
         };
 
         let mut rdef = if config.is_root() || !self.rdef.is_empty() {

ntex/src/web/test.rs

@@ -295,6 +295,7 @@ pub async fn respond_to<T: Responder<DefaultError>>(
 ///     assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
 /// }
 /// ```
+#[derive(Debug)]
 pub struct TestRequest {
     req: HttpTestRequest,
     rmap: ResourceMap,
@@ -828,6 +829,7 @@ impl TestServerConfig {
     }
 }
 
+#[derive(Debug)]
 /// Test server controller
 pub struct TestServer {
     addr: net::SocketAddr,

ntex/src/web/types/json.rs

@@ -253,6 +253,21 @@ impl Default for JsonConfig {
     }
 }
 
+impl fmt::Debug for JsonConfig {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("JsonConfig")
+            .field("limit", &self.limit)
+            .field(
+                "content_type",
+                &self
+                    .content_type
+                    .as_ref()
+                    .map(|_| "Arc<dyn Fn(mime::Mime) -> bool + Send + Sync>"),
+            )
+            .finish()
+    }
+}
+
 /// Request's payload json parser, it resolves to a deserialized `T` value.
 ///
 /// Returns error:

ntex/src/ws/sink.rs

@@ -3,9 +3,10 @@ use std::{future::Future, rc::Rc};
 use crate::io::{IoRef, OnDisconnect};
 use crate::ws;
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct WsSink(Rc<WsSinkInner>);
 
+#[derive(Debug)]
 struct WsSinkInner {
     io: IoRef,
     codec: ws::Codec,

ntex/src/ws/transport.rs

@@ -15,6 +15,7 @@ bitflags::bitflags! {
     }
 }
 
+#[derive(Clone, Debug)]
 /// An implementation of WebSockets streams
 pub struct WsTransport {
     pool: PoolRef,
@@ -171,6 +172,7 @@ impl FilterLayer for WsTransport {
     }
 }
 
+#[derive(Clone, Debug)]
 /// WebSockets transport factory
 pub struct WsTransportFactory {
     codec: Codec,