Cargo.toml

@@ -1,13 +1,15 @@
 [package]
 name = "tide_tracing"
-version = "0.7.0"
+version = "0.5.0"
 authors = ["Michael Pfaff <michael@pfaff.dev>"]
-edition = "2021"
+edition = "2018"
 license = "MIT OR Apache-2.0"
 
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
 [dependencies]
 nrid = { git = "https://git.pfaff.dev/michael/nrid.rs.git", tag = "v0.2.0", default-features = false }
-tide = { version = "0.16", default-features = false }
+tide = "0.16"
 tracing = "0.1"
 async-trait = "0.1"
-num_enum = "0.7"
+num_enum = "0.5.1"

src/lib.rs

@@ -1,14 +1,21 @@
+#![feature(const_trait_impl)]
+#![feature(const_fn_trait_bound)]
+
 #[macro_use]
 extern crate tracing;
 
 use nrid::Nrid;
+use std::time::Instant;
 use tide::Middleware;
 use tide::Next;
 use tide::Request;
 use tracing::Instrument;
 
-/// A traceable component of a [`Request`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, num_enum::FromPrimitive)]
+#[derive(Clone, Copy, Debug, Eq)]
+#[repr(transparent)]
+pub struct ReqComps(u8);
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, num_enum::FromPrimitive)]
 #[repr(u8)]
 pub enum ReqComp {
     #[num_enum(default)]
@@ -19,125 +26,102 @@ pub enum ReqComp {
     Query = 0b00001000,
 }
 
-/// A selection of traceable components of a [`Request`].
-#[derive(Debug, Clone, Copy, Eq, Hash)]
-#[repr(transparent)]
-pub struct ReqComps(u8);
-
 impl ReqComps {
-    #[inline]
-    pub const fn contains(self, mask: ReqComp) -> bool {
-        self.bitand_one(mask).0 == mask as u8
-    }
-
-    #[inline]
-    pub const fn contains_all(self, mask: Self) -> bool {
-        self.bitand_self(mask).0 == mask.0
-    }
-
-    #[inline]
-    const fn bitand_self(self, rhs: Self) -> Self {
-        Self((self.0 as u8) & (rhs.0 as u8))
-    }
-
-    #[inline]
-    const fn bitand_one(self, rhs: ReqComp) -> Self {
-        Self((self.0 as u8) & (rhs as u8))
-    }
-}
-
-impl Default for ReqComps {
-    #[inline]
-    fn default() -> Self {
-        Self(0)
-    }
-}
-
-impl From<ReqComp> for ReqComps {
-    #[inline]
-    fn from(comp: ReqComp) -> Self {
+    pub const fn of(comp: ReqComp) -> Self {
         Self(comp as u8)
     }
+
+    pub const fn contains(self, mask: ReqComp) -> bool {
+        self & mask == mask
+    }
+
+    pub const fn contains_many(self, mask: ReqComps) -> bool {
+        self & mask == mask
+    }
 }
 
-impl core::cmp::PartialEq for ReqComps {
-    #[inline]
+impl const Into<ReqComps> for ReqComp {
+    fn into(self) -> ReqComps {
+        ReqComps::of(self)
+    }
+}
+
+impl const core::cmp::PartialEq<ReqComp> for ReqComps {
+    fn eq(&self, comp: &ReqComp) -> bool {
+        self.0 & (*comp as u8) == *comp as u8
+    }
+}
+
+impl const core::cmp::PartialEq for ReqComps {
     fn eq(&self, comp: &Self) -> bool {
         self.0 == comp.0
     }
 }
 
-impl core::ops::BitOr for ReqComp {
+impl const core::ops::BitOr for ReqComp {
     type Output = ReqComps;
 
-    #[inline]
     fn bitor(self, rhs: Self) -> Self::Output {
         ReqComps((self as u8) | (rhs as u8))
     }
 }
 
-impl core::ops::BitOr for ReqComps {
+impl const core::ops::BitOr for ReqComps {
     type Output = ReqComps;
 
-    #[inline]
     fn bitor(self, rhs: Self) -> Self::Output {
-        ReqComps(self.0 | rhs.0)
+        ReqComps((self.0 as u8) | (rhs.0 as u8))
     }
 }
 
-impl core::ops::BitOr<ReqComp> for ReqComps {
+impl const core::ops::BitOr<ReqComp> for ReqComps {
     type Output = ReqComps;
 
-    #[inline]
     fn bitor(self, rhs: ReqComp) -> Self::Output {
         ReqComps((self.0 as u8) | (rhs as u8))
     }
 }
 
+// TODO make `const` when is "stable" #57349 <https://github.com/rust-lang/rust/issues/57349>
 impl core::ops::BitOrAssign for ReqComps {
-    #[inline]
     fn bitor_assign(&mut self, rhs: ReqComps) {
         self.0 = (self.0 as u8) | (rhs.0 as u8)
     }
 }
 
+// TODO make `const` when is "stable" #57349 <https://github.com/rust-lang/rust/issues/57349>
 impl core::ops::BitOrAssign<ReqComp> for ReqComps {
-    #[inline]
     fn bitor_assign(&mut self, rhs: ReqComp) {
         self.0 = (self.0 as u8) | (rhs as u8)
     }
 }
 
-impl core::ops::BitAnd for ReqComp {
+impl const core::ops::BitAnd for ReqComp {
     type Output = ReqComps;
 
-    #[inline]
     fn bitand(self, rhs: Self) -> Self::Output {
         ReqComps((self as u8) & (rhs as u8))
     }
 }
 
-impl core::ops::BitAnd for ReqComps {
+impl const core::ops::BitAnd for ReqComps {
     type Output = ReqComps;
 
-    #[inline]
     fn bitand(self, rhs: Self) -> Self::Output {
-        self.bitand_self(rhs)
+        ReqComps((self.0 as u8) & (rhs.0 as u8))
     }
 }
 
-impl core::ops::BitAnd<ReqComp> for ReqComps {
+impl const core::ops::BitAnd<ReqComp> for ReqComps {
     type Output = ReqComps;
 
-    #[inline]
     fn bitand(self, rhs: ReqComp) -> Self::Output {
-        self.bitand_one(rhs)
+        ReqComps((self.0 as u8) & (rhs as u8))
     }
 }
 
 // TODO make `const` when is "stable" #57349 <https://github.com/rust-lang/rust/issues/57349>
 impl core::ops::BitAndAssign for ReqComps {
-    #[inline]
     fn bitand_assign(&mut self, rhs: ReqComps) {
         self.0 = (self.0 as u8) & (rhs.0 as u8)
     }
@@ -145,7 +129,6 @@ impl core::ops::BitAndAssign for ReqComps {
 
 // TODO make `const` when is "stable" #57349 <https://github.com/rust-lang/rust/issues/57349>
 impl core::ops::BitAndAssign<ReqComp> for ReqComps {
-    #[inline]
     fn bitand_assign(&mut self, rhs: ReqComp) {
         self.0 = (self.0 as u8) & (rhs as u8)
     }
@@ -157,7 +140,6 @@ pub struct LogMiddleware {
 }
 
 impl Default for LogMiddleware {
-    #[inline]
     fn default() -> Self {
         Self {
             components: ReqComp::Method | ReqComp::Path,
@@ -172,39 +154,31 @@ impl LogMiddleware {
         next: Next<'a, State>,
     ) -> tide::Result {
         let id = Nrid::now();
-        use tracing::field::Empty;
-        let span = debug_span!("Request", id = %id, "http.method" = Empty, "http.path" = Empty, "conn.ip" = Empty, "http.query" = Empty);
+        let span = debug_span!("Request", id = %id);
+        let comp = self.components;
         let url = req.url();
-        if self.components.contains(ReqComp::Method) {
+        if comp.contains(ReqComp::Method) {
             span.record("http.method", &tracing::field::display(req.method()));
         }
-        if self.components.contains(ReqComp::Path) {
+        if comp.contains(ReqComp::Path) {
             span.record("http.path", &url.path());
         }
-        if self.components.contains(ReqComp::IP) {
-            span.record(
-                "conn.ip",
-                &tracing::field::display(req.remote().unwrap_or("unknown").to_string()),
-            );
+        if comp.contains(ReqComp::IP) {
+            span.record("conn.ip", &tracing::field::display(req.remote().unwrap_or("unknown").to_string()));
         }
-        if self.components.contains(ReqComp::Query) {
+        if comp.contains(ReqComp::Query) {
             span.record("http.query", &url.query().unwrap_or(""));
         }
-        async move {
+        Ok(async {
+            let start = Instant::now();
             let res = next.run(req).await;
+            let duration = start.elapsed();
             let status = res.status();
-            match res.error() {
-                Some(e) => {
-                    error!(status = %status, "Response with internal error: {e:?}");
-                }
-                None => {
-                    debug!(status = %status, "Response");
-                }
-            }
-            Ok(res)
+            debug_span!("Response", status = %status, duration = ?duration).in_scope(|| {});
+            res
         }
         .instrument(span)
-        .await
+        .await)
     }
 }
 
@@ -214,23 +188,3 @@ impl<State: Clone + Send + Sync + 'static> Middleware<State> for LogMiddleware {
         self.log(req, next).await
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_mask() {
-        const FIELDS: &'static [ReqComp] = &[ReqComp::Path, ReqComp::IP];
-
-        let mut comps = ReqComps::default();
-
-        for field in FIELDS {
-            comps |= *field;
-        }
-
-        assert!(comps.contains(ReqComp::Path));
-        assert!(comps.contains(ReqComp::IP));
-        assert!(!comps.contains(ReqComp::Query));
-    }
-}