Adopt Tracing

Cargo.toml

@@ -42,4 +42,4 @@ members = [
   "examples/tls",
   "examples/fairings",
   "examples/hello_2018",
-]
+]

contrib/codegen/src/database.rs

@@ -99,15 +99,15 @@ pub fn database_attr(attr: TokenStream, input: TokenStream) -> Result<TokenStrea
                     match pool {
                         Ok(Ok(p)) => Ok(rocket.manage(#pool_type(p))),
                         Err(config_error) => {
-                            ::rocket::logger::error(
+                            ::rocket::trace::error(
                                 &format!("Database configuration failure: '{}'", #name));
-                            ::rocket::logger::error_(&format!("{}", config_error));
+                            ::rocket::trace::error_(&format!("{}", config_error));
                             Err(rocket)
                         },
                         Ok(Err(pool_error)) => {
-                            ::rocket::logger::error(
+                            ::rocket::trace::error(
                                 &format!("Failed to initialize pool for '{}'", #name));
-                            ::rocket::logger::error_(&format!("{:?}", pool_error));
+                            ::rocket::trace::error_(&format!("{:?}", pool_error));
                             Err(rocket)
                         },
                     }

contrib/lib/Cargo.toml

@@ -42,7 +42,7 @@ memcache_pool = ["databases", "memcache", "r2d2-memcache"]
 tokio = { version = "0.2.0", optional = true }
 rocket_contrib_codegen = { version = "0.5.0-dev", path = "../codegen", optional = true }
 rocket = { version = "0.5.0-dev", path = "../../core/lib/", default-features = false }
-log = "0.4"
+tracing = { version = "0.1", default-features = false }
 
 # Serialization and templating dependencies.
 serde = { version = "1.0", optional = true }

contrib/lib/src/compression/fairing.rs

@@ -115,17 +115,17 @@ impl Fairing for Compression {
                         if let Value::String(s) = ex {
                             let mt = MediaType::parse_flexible(s);
                             if mt.is_none() {
-                                warn_!("Ignoring invalid media type '{:?}'", s);
+                                warn!("Ignoring invalid media type '{:?}'", s);
                             }
                             mt
                         } else {
-                            warn_!("Ignoring non-string media type '{:?}'", ex);
+                            warn!("Ignoring non-string media type '{:?}'", ex);
                             None
                         }
                     }).collect();
                 }
                 None => {
-                    warn_!(
+                    warn!(
                         "Exclusions is not an array; using default compression exclusions '{:?}'",
                         ctxt.exclusions
                     );
@@ -134,7 +134,7 @@ impl Fairing for Compression {
             Err(ConfigError::Missing(_)) => { /* ignore missing */ }
             Err(e) => {
                 e.pretty_print();
-                warn_!(
+                warn!(
                     "Using default compression exclusions '{:?}'",
                     ctxt.exclusions
                 );

contrib/lib/src/helmet/helmet.rs

@@ -172,7 +172,7 @@ impl SpaceHelmet {
             let name = policy.name();
             if response.headers().contains(name.as_str()) {
                 warn!("Space Helmet: response contains a '{}' header.", name);
-                warn_!("Refusing to overwrite existing header.");
+                warn!("Refusing to overwrite existing header.");
                 continue
             }
 
@@ -206,9 +206,9 @@ impl Fairing for SpaceHelmet {
             && !cargo.config().environment.is_dev()
             && !self.is_enabled::<Hsts>()
         {
-            warn_!("Space Helmet: deploying with TLS without enabling HSTS.");
-            warn_!("Enabling default HSTS policy.");
-            info_!("To disable this warning, configure an HSTS policy.");
+            warn!("Space Helmet: deploying with TLS without enabling HSTS.");
+            warn!("Enabling default HSTS policy.");
+            info!("To disable this warning, configure an HSTS policy.");
             self.force_hsts.store(true, Ordering::Relaxed);
         }
     }

contrib/lib/src/json.rs

@@ -147,7 +147,7 @@ impl<'a, T: Deserialize<'a>> FromTransformedData<'a> for Json<T> {
             match serde_json::from_str(&string) {
                 Ok(v) => Success(Json(v)),
                 Err(e) => {
-                    error_!("Couldn't parse JSON body: {:?}", e);
+                    error!("Couldn't parse JSON body: {:?}", e);
                     if e.is_data() {
                         Failure((Status::UnprocessableEntity, JsonError::Parse(string, e)))
                     } else {
@@ -166,7 +166,7 @@ impl<'r, T: Serialize> Responder<'r, 'static> for Json<T> {
     fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
         let string = serde_json::to_string(&self.0)
             .map_err(|e| {
-                error_!("JSON failed to serialize: {:?}", e);
+                error!("JSON failed to serialize: {:?}", e);
                 Status::InternalServerError
             })?;
 

contrib/lib/src/lib.rs

@@ -40,7 +40,7 @@
 //! This crate is expected to grow with time, bringing in outside crates to be
 //! officially supported by Rocket.
 
-#[allow(unused_imports)] #[macro_use] extern crate log;
+#[allow(unused_imports)] #[macro_use] extern crate tracing;
 #[allow(unused_imports)] #[macro_use] extern crate rocket;
 
 #[cfg(feature="json")] #[macro_use] pub mod json;

contrib/lib/src/msgpack.rs

@@ -138,7 +138,7 @@ impl<'a, T: Deserialize<'a>> FromTransformedData<'a> for MsgPack<T> {
             match rmp_serde::from_slice(&buf) {
                 Ok(val) => Success(MsgPack(val)),
                 Err(e) => {
-                    error_!("Couldn't parse MessagePack body: {:?}", e);
+                    error!("Couldn't parse MessagePack body: {:?}", e);
                     match e {
                         TypeMismatch(_) | OutOfRange | LengthMismatch(_) => {
                             Failure((Status::UnprocessableEntity, e))
@@ -158,7 +158,7 @@ impl<'r, T: Serialize> Responder<'r, 'static> for MsgPack<T> {
     fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
         let buf = rmp_serde::to_vec(&self.0)
             .map_err(|e| {
-                error_!("MsgPack failed to serialize: {:?}", e);
+                error!("MsgPack failed to serialize: {:?}", e);
                 Status::InternalServerError
             })?;
 

contrib/lib/src/templates/context.rs

@@ -28,10 +28,10 @@ impl Context {
             for path in glob::glob(glob_path).unwrap().filter_map(Result::ok) {
                 let (name, data_type_str) = split_path(&root, &path);
                 if let Some(info) = templates.get(&*name) {
-                    warn_!("Template name '{}' does not have a unique path.", name);
-                    info_!("Existing path: {:?}", info.path);
-                    info_!("Additional path: {:?}", path);
-                    warn_!("Using existing path for template '{}'.", name);
+                    let span = warn_span!("invalid_template_path", "Template name '{}' does not have a unique path.", name);
+                    info!(parent: &span, "Existing path: {:?}", info.path);
+                    info!(parent: &span, "Additional path: {:?}", path);
+                    warn!(parent: &span, "Using existing path for template '{}'.", name);
                     continue;
                 }
 

contrib/lib/src/templates/fairing.rs

@@ -61,8 +61,8 @@ mod context {
                 Ok(watcher) => Some(Mutex::new((watcher, rx))),
                 Err(e) => {
                     warn!("Failed to enable live template reloading: {}", e);
-                    debug_!("Reload error: {:?}", e);
-                    warn_!("Live template reloading is unavailable.");
+                    debug!("Reload error: {:?}", e);
+                    warn!("Live template reloading is unavailable.");
                     None
                 }
             };
@@ -98,14 +98,14 @@ mod context {
                 }
 
                 if changed {
-                    info_!("Change detected: reloading templates.");
+                    info!("Change detected: reloading templates.");
                     let mut ctxt = self.context_mut();
                     if let Some(mut new_ctxt) = Context::initialize(ctxt.root.clone()) {
                         custom_callback(&mut new_ctxt.engines);
                         *ctxt = new_ctxt;
                     } else {
-                        warn_!("An error occurred while reloading templates.");
-                        warn_!("The previous templates will remain active.");
+                        warn!("An error occurred while reloading templates.");
+                        warn!("The previous templates will remain active.");
                     };
                 }
             });
@@ -159,7 +159,7 @@ impl Fairing for TemplateFairing {
             Err(ConfigError::Missing(_)) => { /* ignore missing */ }
             Err(e) => {
                 e.pretty_print();
-                warn_!("Using default templates directory '{:?}'", template_root);
+                warn!("Using default templates directory '{:?}'", template_root);
             }
         };
 

contrib/lib/src/templates/handlebars_templates.rs

@@ -13,8 +13,8 @@ impl Engine for Handlebars<'static> {
             let path = &info.path;
             if let Err(e) = hb.register_template_file(name, path) {
                 error!("Error in Handlebars template '{}'.", name);
-                info_!("{}", e);
-                info_!("Template path: '{}'.", path.to_string_lossy());
+                info!("{}", e);
+                info!("Template path: '{}'.", path.to_string_lossy());
                 return None;
             }
         }
@@ -24,14 +24,14 @@ impl Engine for Handlebars<'static> {
 
     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);
+            error!("Handlebars template '{}' does not exist.", name);
             return None;
         }
 
         match Handlebars::render(self, name, &context) {
             Ok(string) => Some(string),
             Err(e) => {
-                error_!("Error rendering Handlebars template '{}': {}", name, e);
+                error!("Error rendering Handlebars template '{}': {}", name, e);
                 None
             }
         }

contrib/lib/src/templates/metadata.rs

@@ -93,9 +93,9 @@ impl<'a, 'r> FromRequest<'a, 'r> for Metadata<'a> {
             .succeeded()
             .and_then(|cm| Some(request::Outcome::Success(Metadata(cm.inner()))))
             .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 fairing.");
+                info!("To use templates, you must attach `Template::fairing()`.");
+                info!("See the `Template` documentation for more information.");
                 request::Outcome::Failure((Status::InternalServerError, ()))
             })
     }

contrib/lib/src/templates/mod.rs

@@ -362,19 +362,19 @@ impl Template {
         let name = &*self.name;
         let info = ctxt.templates.get(name).ok_or_else(|| {
             let ts: Vec<_> = ctxt.templates.keys().map(|s| s.as_str()).collect();
-            error_!("Template '{}' does not exist.", name);
-            info_!("Known templates: {}", ts.join(","));
-            info_!("Searched in '{:?}'.", ctxt.root);
+            error!("Template '{}' does not exist.", name);
+            info!("Known templates: {}", ts.join(","));
+            info!("Searched in '{:?}'.", ctxt.root);
             Status::InternalServerError
         })?;
 
         let value = self.value.ok_or_else(|| {
-            error_!("The provided template context failed to serialize.");
+            error!("The provided template context failed to serialize.");
             Status::InternalServerError
         })?;
 
         let string = ctxt.engines.render(name, &info, value).ok_or_else(|| {
-            error_!("Template '{}' failed to render.", name);
+            error!("Template '{}' failed to render.", name);
             Status::InternalServerError
         })?;
 
@@ -389,9 +389,9 @@ impl<'r> Responder<'r, 'static> for Template {
     fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
         let (render, content_type) = {
             let ctxt = req.managed_state::<ContextManager>().ok_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 fairing.");
+                info!("To use templates, you must attach `Template::fairing()`.");
+                info!("See the `Template` documentation for more information.");
                 Status::InternalServerError
             })?.context();
 

contrib/lib/src/templates/tera_templates.rs

@@ -25,7 +25,7 @@ impl Engine for Tera {
 
             let mut error = Some(&e as &dyn Error);
             while let Some(err) = error {
-                info_!("{}", err);
+                info!("{}", err);
                 error = err.source();
             }
 
@@ -37,14 +37,14 @@ impl Engine for 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);
+            error!("Tera template '{}' does not exist.", name);
             return None;
         };
 
         let tera_ctx = match Context::from_serialize(context) {
             Ok(ctx) => ctx,
             Err(_) => {
-                error_!(
+                error!(
                     "Error generating context when rendering Tera template '{}'.",
                     name
                 );
@@ -55,11 +55,11 @@ impl Engine for Tera {
         match Tera::render(self, name, &tera_ctx) {
             Ok(string) => Some(string),
             Err(e) => {
-                error_!("Error rendering Tera template '{}'.", name);
+                error!("Error rendering Tera template '{}'.", name);
 
                 let mut error = Some(&e as &dyn Error);
                 while let Some(err) = error {
-                    error_!("{}", err);
+                    error!("{}", err);
                     error = err.source();
                 }
 

core/lib/Cargo.toml

@@ -39,6 +39,7 @@ atty = "0.2"
 async-trait = "0.1"
 ref-cast = "1.0"
 atomic = "0.4"
+tracing = "0.1.19"
 ubyte = "0.9.1"
 
 [dependencies.pear]
@@ -49,6 +50,16 @@ rev = "4b68055"
 version = "0.2.9"
 features = ["fs", "io-std", "io-util", "rt-threaded", "sync", "signal", "macros"]
 
+[dependencies.tracing-subscriber]
+version = "0.2.9"
+default-features = false
+features = ["fmt", "env-filter", "smallvec"]
+
+[dependencies.tracing-futures]
+version = "0.2"
+default-features = false
+features = ["std-future"]
+
 [build-dependencies]
 yansi = "0.5"
 version_check = "0.9.1"

core/lib/src/config/error.rs

@@ -64,46 +64,46 @@ impl ConfigError {
             RandFailure => error!("failed to read randomness from the OS"),
             Io(ref error, param) => {
                 error!("I/O error while setting {}:", Paint::default(param).bold());
-                info_!("{}", error);
+                info!("{}", error);
             }
             BadFilePath(ref path, reason) => {
                 error!("configuration file path {} is invalid",
                     Paint::default(path.display()).bold());
-                info_!("{}", reason);
+                info!("{}", reason);
             }
             BadEntry(ref name, ref filename) => {
                 let valid_entries = format!("{}, global", valid_envs);
                 error!("{} is not a known configuration environment",
                        Paint::default(format!("[{}]", name)).bold());
-                info_!("in {}", Paint::default(filename.display()).bold());
-                info_!("valid environments are: {}", Paint::default(valid_entries).bold());
+                info!("in {}", Paint::default(filename.display()).bold());
+                info!("valid environments are: {}", Paint::default(&valid_entries).bold());
             }
             BadEnv(ref name) => {
                 error!("{} is not a valid ROCKET_ENV value", Paint::default(name).bold());
-                info_!("valid environments are: {}", Paint::default(valid_envs).bold());
+                info!("valid environments are: {}", Paint::default(valid_envs).bold());
             }
             BadType(ref name, expected, actual, ref filename) => {
                 error!("{} key could not be parsed", Paint::default(name).bold());
                 if let Some(filename) = filename {
-                    info_!("in {}", Paint::default(filename.display()).bold());
+                    info!("in {}", Paint::default(filename.display()).bold());
                 }
 
-                info_!("expected value to be {}, but found {}",
+                info!("expected value to be {}, but found {}",
                        Paint::default(expected).bold(), Paint::default(actual).bold());
             }
             ParseError(_, ref filename, ref desc, line_col) => {
                 error!("config file failed to parse due to invalid TOML");
-                info_!("{}", desc);
-                info_!("in {}", Paint::default(filename.display()).bold());
+                info!("{}", desc);
+                info!("in {}", Paint::default(filename.display()).bold());
                 if let Some((line, col)) = line_col {
-                    info_!("at line {}, column {}",
+                    info!("at line {}, column {}",
                            Paint::default(line + 1).bold(), Paint::default(col + 1).bold());
                 }
             }
             BadEnvVal(ref key, ref value, ref error) => {
                 error!("environment variable {} could not be parsed",
                    Paint::default(format!("ROCKET_{}={}", key.to_uppercase(), value)).bold());
-                info_!("{}", error);
+                info!("{}", error);
             }
             UnknownKey(ref key) => {
                 error!("the configuration key {} is unknown and disallowed in \