Remove old 'log' macros. Color via subscriber.

This commit:
  - Removes painting outside trace subscriber in core.
  - Removes all non-subscriber uses of yansi.
  - Removes all uses of old log macros.
  - Fix trace exports.

Author: SergioBenitez

contrib/db_pools/lib/src/database.rs

@@ -1,13 +1,11 @@
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
-use rocket::{error, info_, Build, Ignite, Phase, Rocket, Sentinel, Orbit};
+use rocket::{error, Build, Ignite, Phase, Rocket, Sentinel, Orbit};
 use rocket::fairing::{self, Fairing, Info, Kind};
 use rocket::request::{FromRequest, Outcome, Request};
-use rocket::http::Status;
-
-use rocket::yansi::Paint;
 use rocket::figment::providers::Serialized;
+use rocket::http::Status;
 
 use crate::Pool;
 
@@ -122,10 +120,10 @@ pub trait Database: From<Self::Pool> + DerefMut<Target = Self::Pool> + Send + Sy
             return Some(db);
         }
 
-        let dbtype = std::any::type_name::<Self>().bold().primary();
-        error!("Attempted to fetch unattached database `{}`.", dbtype);
-        info_!("`{}{}` fairing must be attached prior to using this database.",
-            dbtype.linger(), "::init()".resetting());
+        let conn = std::any::type_name::<Self>();
+        error!("`{conn}::init()` is not attached\n\
+            the fairing must be attached to use `{conn}` in routes.");
+
         None
     }
 }
@@ -267,7 +265,7 @@ impl<D: Database> Fairing for Initializer<D> {
         match <D::Pool>::init(&figment).await {
             Ok(pool) => Ok(rocket.manage(D::from(pool))),
             Err(e) => {
-                error!("failed to initialize database: {}", e);
+                error!("database initialization failed: {e}");
                 Err(rocket)
             }
         }

contrib/dyn_templates/src/context.rs

@@ -49,24 +49,25 @@ impl Context {
                     Ok(_) | Err(_) => continue,
                 };
 
-                let (name, data_type_str) = split_path(&root, entry.path());
-                if let Some(info) = templates.get(&*name) {
-                    warn_!("Template name '{}' does not have a unique source.", name);
-                    match info.path {
-                        Some(ref path) => info_!("Existing path: {:?}", path),
-                        None => info_!("Existing Content-Type: {}", info.data_type),
-                    }
-
-                    info_!("Additional path: {:?}", entry.path());
-                    warn_!("Keeping existing template '{}'.", name);
+                let (template, data_type_str) = split_path(&root, entry.path());
+                if let Some(info) = templates.get(&*template) {
+                    warn!(
+                        %template,
+                        first_path = %entry.path().display(),
+                        second_path = info.path.as_ref().map(|p| display(p.display())),
+                        data_type = %info.data_type,
+                        "Template name '{template}' can refer to multiple templates.\n\
+                         First path will be used. Second path is ignored."
+                    );
+
                     continue;
                 }
 
                 let data_type = data_type_str.as_ref()
                     .and_then(|ext| ContentType::from_extension(ext))
                     .unwrap_or(ContentType::Text);
 
-                templates.insert(name, TemplateInfo {
+                templates.insert(template, TemplateInfo {
                     path: Some(entry.into_path()),
                     engine_ext: ext,
                     data_type,
@@ -75,9 +76,8 @@ impl Context {
         }
 
         let mut engines = Engines::init(&templates)?;
-        if let Err(e) = callback(&mut engines) {
-            error_!("Template customization callback failed.");
-            error_!("{}", e);
+        if let Err(reason) = callback(&mut engines) {
+            error!(%reason, "template customization callback failed");
             return None;
         }
 
@@ -151,9 +151,8 @@ mod manager {
             let watcher = match watcher {
                 Ok(watcher) => Some((watcher, Mutex::new(rx))),
                 Err(e) => {
-                    warn!("Failed to enable live template reloading: {}", e);
-                    debug_!("Reload error: {:?}", e);
-                    warn_!("Live template reloading is unavailable.");
+                    warn!("live template reloading initialization failed: {e}\n\
+                        live template reloading is unavailable");
                     None
                 }
             };
@@ -182,13 +181,13 @@ mod manager {
                 .map(|(_, rx)| rx.lock().expect("fsevents lock").try_iter().count() > 0);
 
             if let Some(true) = templates_changes {
-                info_!("Change detected: reloading templates.");
+                debug!("template change detected: reloading templates");
                 let root = self.context().root.clone();
                 if let Some(new_ctxt) = Context::initialize(&root, callback) {
                     *self.context_mut() = new_ctxt;
                 } else {
-                    warn_!("An error occurred while reloading templates.");
-                    warn_!("Existing templates will remain active.");
+                    warn!("error while reloading template\n\
+                        existing templates will remain active.")
                 };
             }
         }

contrib/dyn_templates/src/engine/handlebars.rs

@@ -11,26 +11,26 @@ impl Engine for Handlebars<'static> {
     fn init<'a>(templates: impl Iterator<Item = (&'a str, &'a Path)>) -> Option<Self> {
         let mut hb = Handlebars::new();
         let mut ok = true;
-        for (name, path) in templates {
-            if let Err(e) = hb.register_template_file(name, path) {
-                error!("Handlebars template '{}' failed to register.", name);
-                error_!("{}", e);
-                info_!("Template path: '{}'.", path.to_string_lossy());
+        for (template, path) in templates {
+            if let Err(e) = hb.register_template_file(template, path) {
+                error!(template, path = %path.display(),
+                    "failed to register Handlebars template: {e}");
+
                 ok = false;
             }
         }
 
         ok.then_some(hb)
     }
 
-    fn render<C: Serialize>(&self, name: &str, context: C) -> Option<String> {
-        if self.get_template(name).is_none() {
-            error_!("Handlebars template '{}' does not exist.", name);
+    fn render<C: Serialize>(&self, template: &str, context: C) -> Option<String> {
+        if self.get_template(template).is_none() {
+            error!(template, "requested Handlebars template does not exist.");
             return None;
         }
 
-        Handlebars::render(self, name, &context)
-            .map_err(|e| error_!("Handlebars: {}", e))
+        Handlebars::render(self, template, &context)
+            .map_err(|e| error!("Handlebars render error: {}", e))
             .ok()
     }
 }

contrib/dyn_templates/src/engine/minijinja.rs

@@ -43,23 +43,22 @@ impl Engine for Environment<'static> {
     }
 
     fn render<C: Serialize>(&self, name: &str, context: C) -> Option<String> {
-        let template = match self.get_template(name) {
-            Ok(template) => template,
-            Err(e) => {
-                error_!("Minijinja template '{name}' error: {e}");
-                return None;
-            }
+        let Ok(template) = self.get_template(name) else {
+            error!("Minijinja template '{name}' was not found.");
+            return None;
         };
 
         match template.render(context) {
             Ok(result) => Some(result),
             Err(e) => {
-                error_!("Error rendering Minijinja template '{name}': {e}");
-                let mut error = &e as &dyn std::error::Error;
-                while let Some(source) = error.source() {
-                    error_!("caused by: {source}");
-                    error = source;
-                }
+                error_span!("Error rendering Minijinja template '{name}': {e}" => {
+                    let mut error = &e as &dyn std::error::Error;
+                    while let Some(source) = error.source() {
+                        error_!("caused by: {source}");
+                        error = source;
+                    }
+                });
+
                 None
             }
         }

contrib/dyn_templates/src/engine/tera.rs

@@ -21,39 +21,40 @@ impl Engine for Tera {
 
         // Finally try to tell Tera about all of the templates.
         if let Err(e) = tera.add_template_files(files) {
-            error!("Failed to initialize Tera templating.");
-
-            let mut error = Some(&e as &dyn Error);
-            while let Some(err) = error {
-                info_!("{}", err);
-                error = err.source();
-            }
+            error_span!("Tera templating initialization failed" => {
+                let mut error = Some(&e as &dyn Error);
+                while let Some(err) = error {
+                    error!("{err}");
+                    error = err.source();
+                }
+            });
 
             None
         } else {
             Some(tera)
         }
     }
 
-    fn render<C: Serialize>(&self, name: &str, context: C) -> Option<String> {
-        if self.get_template(name).is_err() {
-            error_!("Tera template '{}' does not exist.", name);
+    fn render<C: Serialize>(&self, template: &str, context: C) -> Option<String> {
+        if self.get_template(template).is_err() {
+            error!(template, "requested template does not exist");
             return None;
         };
 
         let tera_ctx = Context::from_serialize(context)
-            .map_err(|e| error_!("Tera context error: {}.", e))
+            .map_err(|e| error!("Tera context error: {}.", e))
             .ok()?;
 
-        match Tera::render(self, name, &tera_ctx) {
+        match Tera::render(self, template, &tera_ctx) {
             Ok(string) => Some(string),
             Err(e) => {
-                error_!("Error rendering Tera template '{name}': {e}");
-                let mut error = Some(&e as &dyn Error);
-                while let Some(err) = error {
-                    error_!("{}", err);
-                    error = err.source();
-                }
+                error_span!("failed to render Tera template {name}" [template] => {
+                    let mut error = Some(&e as &dyn Error);
+                    while let Some(err) = error {
+                        error!("{err}");
+                        error = err.source();
+                    }
+                });
 
                 None
             }

contrib/dyn_templates/src/fairing.rs

@@ -48,7 +48,7 @@ impl Fairing for TemplateFairing {
         if let Some(ctxt) = Context::initialize(&path, &self.callback) {
             Ok(rocket.manage(ContextManager::new(ctxt)))
         } else {
-            error_!("Template initialization failed. Aborting launch.");
+            error!("Template initialization failed. Aborting launch.");
             Err(rocket)
         }
     }
@@ -57,7 +57,7 @@ impl Fairing for TemplateFairing {
         let cm = rocket.state::<ContextManager>()
             .expect("Template ContextManager registered in on_ignite");
 
-        info_span!("templating" [icon = "📐"] => {
+        info_span!("templating" => {
             info!(directory = %Source::from(&*cm.context().root));
             info!(engines = ?Engines::ENABLED_EXTENSIONS);
         });

contrib/dyn_templates/src/metadata.rs

@@ -5,7 +5,6 @@ use rocket::{Request, Rocket, Ignite, Sentinel};
 use rocket::http::{Status, ContentType};
 use rocket::request::{self, FromRequest};
 use rocket::serde::Serialize;
-use rocket::yansi::Paint;
 
 use crate::{Template, context::ContextManager};
 
@@ -136,11 +135,11 @@ impl fmt::Debug for Metadata<'_> {
 impl Sentinel for Metadata<'_> {
     fn abort(rocket: &Rocket<Ignite>) -> bool {
         if rocket.state::<ContextManager>().is_none() {
-            let md = "Metadata".primary().bold();
-            let fairing = "Template::fairing()".primary().bold();
-            error!("requested `{}` guard without attaching `{}`.", md, fairing);
-            info_!("To use or query templates, you must attach `{}`.", fairing);
-            info_!("See the `Template` documentation for more information.");
+            error!(
+                "uninitialized template context: missing `Template::fairing()`.\n\
+                To use templates, you must attach `Template::fairing()`."
+            );
+
             return true;
         }
 
@@ -159,9 +158,11 @@ impl<'r> FromRequest<'r> for Metadata<'r> {
         request.rocket().state::<ContextManager>()
             .map(|cm| request::Outcome::Success(Metadata(cm)))
             .unwrap_or_else(|| {
-                error_!("Uninitialized template context: missing fairing.");
-                info_!("To use templates, you must attach `Template::fairing()`.");
-                info_!("See the `Template` documentation for more information.");
+                error!(
+                    "uninitialized template context: missing `Template::fairing()`.\n\
+                    To use templates, you must attach `Template::fairing()`."
+                );
+
                 request::Outcome::Error((Status::InternalServerError, ()))
             })
     }