wip: remove painting outside trace in core

Author: SergioBenitez

core/lib/src/catcher/catcher.rs

@@ -8,8 +8,6 @@ use crate::request::Request;
 use crate::http::{Status, ContentType, uri};
 use crate::catcher::{Handler, BoxFuture};
 
-use yansi::Paint;
-
 /// An error catching route.
 ///
 /// Catchers are routes that run when errors are produced by the application.
@@ -342,21 +340,6 @@ impl From<StaticInfo> for Catcher {
     }
 }
 
-impl fmt::Display for Catcher {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(ref n) = self.name {
-            write!(f, "{}{}{} ", "(".cyan(), n.primary(), ")".cyan())?;
-        }
-
-        write!(f, "{} ", self.base.path().green())?;
-
-        match self.code {
-            Some(code) => write!(f, "{}", code.blue()),
-            None => write!(f, "{}", "default".blue()),
-        }
-    }
-}
-
 impl fmt::Debug for Catcher {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Catcher")

core/lib/src/response/debug.rs

@@ -2,8 +2,6 @@ use crate::request::Request;
 use crate::response::{self, Responder};
 use crate::http::Status;
 
-use yansi::Paint;
-
 /// Debug prints the internal value before forwarding to the 500 error catcher.
 ///
 /// This value exists primarily to allow handler return types that would not
@@ -78,16 +76,16 @@ impl<E> From<E> for Debug<E> {
 
 impl<'r, E: std::fmt::Debug> Responder<'r, 'static> for Debug<E> {
     fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
-        warn_!("Debug: {:?}", self.0.primary());
-        warn_!("Debug always responds with {}.", Status::InternalServerError.primary());
+        let type_name = std::any::type_name::<E>();
+        info!(type_name, value = ?self.0, "debug response (500)");
         Err(Status::InternalServerError)
     }
 }
 
 /// Prints a warning with the error and forwards to the `500` error catcher.
 impl<'r> Responder<'r, 'static> for std::io::Error {
     fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
-        warn_!("I/O Error: {:?}", self.primary());
+        warn!("i/o error response: {self}");
         Err(Status::InternalServerError)
     }
 }

core/lib/src/rocket.rs

@@ -4,8 +4,8 @@ use std::sync::Arc;
 use std::time::Duration;
 use std::any::Any;
 use std::future::Future;
+use std::panic::Location;
 
-use yansi::Paint;
 use either::Either;
 use figment::{Figment, Provider};
 use futures::TryFutureExt;
@@ -21,7 +21,6 @@ use crate::phase::{Stateful, StateRef, State};
 use crate::http::uri::Origin;
 use crate::http::ext::IntoOwned;
 use crate::error::{Error, ErrorKind};
-// use crate::log::PaintExt;
 
 /// The application server itself.
 ///
@@ -248,20 +247,18 @@ impl Rocket<Build> {
               B::Error: fmt::Display,
               M: Fn(&Origin<'a>, T) -> T,
               F: Fn(&mut Self, T),
-              T: Clone + fmt::Display,
+              T: Clone + Traceable,
     {
         let mut base = match base.clone().try_into() {
             Ok(origin) => origin.into_owned(),
             Err(e) => {
-                error!("invalid {} base: {}", kind, Paint::white(&base));
-                error_!("{}", e);
-                info_!("{} {}", "in".primary(), std::panic::Location::caller());
+                error!(%base, location = %Location::caller(), "invalid {kind} base uri: {e}");
                 panic!("aborting due to {} base error", kind);
             }
         };
 
         if base.query().is_some() {
-            warn!("query in {} base '{}' is ignored", kind, Paint::white(&base));
+            warn!(%base, location = %Location::caller(), "query in {kind} base is ignored");
             base.clear_query();
         }
 

core/lib/src/route/route.rs

@@ -1,8 +1,6 @@
 use std::fmt;
 use std::borrow::Cow;
 
-use yansi::Paint;
-
 use crate::http::{uri, Method, MediaType};
 use crate::route::{Handler, RouteUri, BoxFuture};
 use crate::sentinel::Sentry;
@@ -343,27 +341,6 @@ impl Route {
     }
 }
 
-impl fmt::Display for Route {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(ref n) = self.name {
-            write!(f, "{}{}{} ", "(".cyan(), n.primary(), ")".cyan())?;
-        }
-
-        write!(f, "{} ", self.method.green())?;
-        self.uri.color_fmt(f)?;
-
-        if self.rank > 1 {
-            write!(f, " [{}]", self.rank.primary().bold())?;
-        }
-
-        if let Some(ref format) = self.format {
-            write!(f, " {}", format.yellow())?;
-        }
-
-        Ok(())
-    }
-}
-
 impl fmt::Debug for Route {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Route")

core/lib/src/route/uri.rs

@@ -238,22 +238,6 @@ impl<'a> RouteUri<'a> {
         // We subtract `3` because `raw_path` is never `0`: 0b0100 = 4 - 3 = 1.
         -((raw_weight as isize) - 3)
     }
-
-    pub(crate) fn color_fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use yansi::Paint;
-
-        let (path, base, unmounted) = (self.uri.path(), self.base(), self.unmounted().path());
-        let unmounted_part = path.strip_prefix(base.as_str())
-            .map(|raw| raw.as_str())
-            .unwrap_or(unmounted.as_str());
-
-        write!(f, "{}{}", self.base().blue().underline(), unmounted_part.blue())?;
-        if let Some(q) = self.unmounted().query() {
-            write!(f, "{}{}", "?".yellow(), q.yellow())?;
-        }
-
-        Ok(())
-    }
 }
 
 impl Metadata {

core/lib/src/router/collider.rs

@@ -226,7 +226,7 @@ mod tests {
             let (a, b) = (dummy_route($ranked, $m1, $p1), dummy_route($ranked, $m2, $p2));
             assert! {
                 a.collides_with(&b),
-                "\nroutes failed to collide:\n{} does not collide with {}\n", a, b
+                "\nroutes failed to collide:\n{:?} does not collide with {:?}\n", a, b
             }
         };
         (ranked $($t:tt)+) => (assert_collision!(true, $($t)+));
@@ -239,7 +239,7 @@ mod tests {
             let (a, b) = (dummy_route($ranked, $m1, $p1), dummy_route($ranked, $m2, $p2));
             assert! {
                 !a.collides_with(&b),
-                "\nunexpected collision:\n{} collides with {}\n", a, b
+                "\nunexpected collision:\n{:?} collides with {:?}\n", a, b
             }
         };
         (ranked $($t:tt)+) => (assert_no_collision!(true, $($t)+));

core/lib/src/router/router.rs

@@ -580,10 +580,10 @@ mod test {
                 let req_status = Status::from_code(req.0).expect("valid status");
                 let catcher = catcher(&router, req_status, req.1).expect("some catcher");
                 assert_eq!(catcher.code, expected.0,
-                    "\nmatched {}, expected {:?} for req {:?}", catcher, expected, req);
+                    "\nmatched {:?}, expected {:?} for req {:?}", catcher, expected, req);
 
                 assert_eq!(catcher.base.path(), expected.1,
-                    "\nmatched {}, expected {:?} for req {:?}", catcher, expected, req);
+                    "\nmatched {:?}, expected {:?} for req {:?}", catcher, expected, req);
             }
         })
     }

core/lib/src/tls/resolver.rs

@@ -73,15 +73,12 @@ impl<T: Resolver> fairing::Fairing for Fairing<T> {
     }
 
     async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
-        use yansi::Paint;
-
         let result = T::init(&rocket).await;
         match result {
             Ok(resolver) => Ok(rocket.manage(Arc::new(resolver) as Arc<dyn Resolver>)),
             Err(e) => {
-                let name = std::any::type_name::<T>();
-                error!("TLS resolver {} failed to initialize.", name.primary().bold());
-                error_!("{e}");
+                let type_name = std::any::type_name::<T>();
+                error!(type_name, reason = %e, "TLS resolver failed to initialize");
                 Err(rocket)
             }
         }

core/lib/src/trace/macros.rs

@@ -1,15 +1,3 @@
-pub trait PaintExt: Sized {
-    fn emoji(self) -> yansi::Painted<Self>;
-}
-
-impl PaintExt for &str {
-    /// Paint::masked(), but hidden on Windows due to broken output. See #1122.
-    fn emoji(self) -> yansi::Painted<Self> {
-        #[cfg(windows)] { yansi::Paint::new("").mask() }
-        #[cfg(not(windows))] { yansi::Paint::new(self).mask() }
-    }
-}
-
 macro_rules! declare_macro {
     ($($name:ident $level:ident),* $(,)?) => (
         $(declare_macro!([$] $name $level);)*

core/lib/src/trace/traceable.rs

@@ -142,7 +142,7 @@ impl Traceable for Route {
             format = self.format.as_ref().map(display),
         }
 
-        event! { Level::DEBUG, "route",
+        event! { Level::DEBUG, "sentinels",
             route = self.name.as_ref().map(|n| &**n),
             sentinels = %Formatter(|f| {
                 f.debug_set()

examples/hello/src/main.rs

@@ -1,5 +1,3 @@
-use rocket::fairing::AdHoc;
-
 #[macro_use] extern crate rocket;
 
 #[cfg(test)] mod tests;