import tracing log macros where possible

Author: syphar

src/build_queue.rs

@@ -8,7 +8,7 @@ use crate::{Config, Index, Metrics, RustwideBuilder};
 use anyhow::Context;
 
 use crates_index_diff::Change;
-use tracing::{debug, info};
+use tracing::{debug, info, warn};
 
 use git2::Oid;
 use std::sync::Arc;
@@ -239,11 +239,9 @@ fn retry<T>(mut f: impl FnMut() -> Result<T>, max_attempts: u32) -> Result<T> {
                     return Err(err);
                 } else {
                     let sleep_for = 2u32.pow(attempt);
-                    tracing::warn!(
+                    warn!(
                         "got error on attempt {}, will try again after {}s:\n{:?}",
-                        attempt,
-                        sleep_for,
-                        err
+                        attempt, sleep_for, err
                     );
                     thread::sleep(Duration::from_secs(sleep_for as u64));
                 }

src/config.rs

@@ -4,6 +4,7 @@ use std::env::VarError;
 use std::error::Error;
 use std::path::PathBuf;
 use std::str::FromStr;
+use tracing::trace;
 
 #[derive(Debug)]
 pub struct Config {
@@ -205,7 +206,7 @@ where
             .map(Some)
             .with_context(|| format!("failed to parse configuration variable {}", var))?),
         Err(VarError::NotPresent) => {
-            tracing::trace!("optional configuration variable {} is not set", var);
+            trace!("optional configuration variable {} is not set", var);
             Ok(None)
         }
         Err(VarError::NotUnicode(_)) => Err(anyhow!("configuration variable {} is not UTF-8", var)),

src/docbuilder/rustwide_builder.rs

@@ -160,8 +160,8 @@ impl RustwideBuilder {
         // NOTE: this ignores the error so that you can still run a build without rustfmt.
         // This should only happen if you run a build for the first time when rustfmt isn't available.
         if let Err(err) = self.toolchain.add_component(&self.workspace, "rustfmt") {
-            tracing::warn!("failed to install rustfmt: {}", err);
-            tracing::info!("continuing anyway, since this must be the first build");
+            warn!("failed to install rustfmt: {}", err);
+            info!("continuing anyway, since this must be the first build");
         }
 
         self.rustc_version = self.detect_rustc_version()?;
@@ -486,7 +486,7 @@ impl RustwideBuilder {
                         // won't lead to non-existing docs.
                         for prefix in &["rustdoc", "sources"] {
                             let prefix = format!("{}/{}/{}/", prefix, name, version);
-                            tracing::debug!("cleaning old storage folder {}", prefix);
+                            debug!("cleaning old storage folder {}", prefix);
                             self.storage.delete_prefix(&prefix)?;
                         }
                     }
@@ -615,8 +615,8 @@ impl RustwideBuilder {
         let doc_coverage = match self.get_coverage(target, build, metadata, limits) {
             Ok(cov) => cov,
             Err(err) => {
-                tracing::info!("error when trying to get coverage: {}", err);
-                tracing::info!("continuing anyways.");
+                info!("error when trying to get coverage: {}", err);
+                info!("continuing anyways.");
                 None
             }
         };

src/index/mod.rs

@@ -1,6 +1,7 @@
 use std::{path::PathBuf, process::Command};
 
 use anyhow::Context;
+use tracing::debug;
 use url::Url;
 
 use self::api::Api;
@@ -90,9 +91,9 @@ impl Index {
     pub(crate) fn crates(&self) -> Result<crates_index::Index> {
         // First ensure the index is up to date, peeking will pull the latest changes without
         // affecting anything else.
-        tracing::debug!("Updating index");
+        debug!("Updating index");
         self.diff()?.peek_changes()?;
-        tracing::debug!("Opening with `crates_index`");
+        debug!("Opening with `crates_index`");
         // crates_index requires the repo url to match the existing origin or it tries to reinitialize the repo
         let repo_url = self
             .repository_url

src/storage/s3.rs

@@ -2,7 +2,7 @@ use super::{Blob, FileRange, StorageTransaction};
 use crate::{Config, Metrics};
 use anyhow::{Context, Error};
 use aws_sdk_s3::{
-    error,
+    error as s3_error,
     model::{Delete, ObjectIdentifier, Tag, Tagging},
     types::SdkError,
     Client, Endpoint, Region, RetryConfig,
@@ -15,6 +15,7 @@ use futures_util::{
 };
 use std::{io::Write, sync::Arc};
 use tokio::runtime::Runtime;
+use tracing::{error, warn};
 
 const PUBLIC_ACCESS_TAG: &str = "static-cloudfront-access";
 const PUBLIC_ACCESS_VALUE: &str = "allow";
@@ -83,7 +84,7 @@ impl S3Backend {
             {
                 Ok(_) => Ok(true),
                 Err(SdkError::ServiceError { err, raw })
-                    if (matches!(err.kind, error::HeadObjectErrorKind::NotFound(_))
+                    if (matches!(err.kind, s3_error::HeadObjectErrorKind::NotFound(_))
                         || raw.http().status() == http::StatusCode::NOT_FOUND) =>
                 {
                     Ok(false)
@@ -174,7 +175,7 @@ impl S3Backend {
                 .send()
                 .map_err(|err| match err {
                     SdkError::ServiceError { err, raw }
-                        if (matches!(err.kind, error::GetObjectErrorKind::NoSuchKey(_))
+                        if (matches!(err.kind, s3_error::GetObjectErrorKind::NoSuchKey(_))
                             || raw.http().status() == http::StatusCode::NOT_FOUND) =>
                     {
                         super::PathNotFoundError.into()
@@ -261,7 +262,7 @@ impl<'a> StorageTransaction for S3StorageTransaction<'a> {
                                 self.s3.metrics.uploaded_files_total.inc();
                             })
                             .map_err(|err| {
-                                tracing::warn!("Failed to upload blob to S3: {:?}", err);
+                                warn!("Failed to upload blob to S3: {:?}", err);
                                 // Reintroduce failed blobs for a retry
                                 blob
                             }),
@@ -324,7 +325,7 @@ impl<'a> StorageTransaction for S3StorageTransaction<'a> {
 
                     if let Some(errs) = resp.errors {
                         for err in &errs {
-                            tracing::error!("error deleting file from s3: {:?}", err);
+                            error!("error deleting file from s3: {:?}", err);
                         }
 
                         anyhow::bail!("deleting from s3 failed");

src/test/fakes.rs

@@ -10,6 +10,7 @@ use chrono::{DateTime, Utc};
 use postgres::Client;
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
+use tracing::debug;
 
 #[must_use = "FakeRelease does nothing until you call .create()"]
 pub(crate) struct FakeRelease<'a> {
@@ -303,14 +304,14 @@ impl<'a> FakeRelease<'a> {
                         .with_context(|| format!("failed to create {}", path.display()))?;
                 }
                 let file = base_path.join(&path);
-                tracing::debug!("writing file {}", file.display());
+                debug!("writing file {}", file.display());
                 fs::write(file, data)?;
             }
             Ok(())
         };
 
         let upload_files = |kind: FileKind, source_directory: &Path| {
-            tracing::debug!(
+            debug!(
                 "adding directory {:?} from {}",
                 kind,
                 source_directory.display()
@@ -324,7 +325,7 @@ impl<'a> FakeRelease<'a> {
                         (source_archive_path(&package.name, &package.version), false)
                     }
                 };
-                tracing::debug!("store in archive: {:?}", archive);
+                debug!("store in archive: {:?}", archive);
                 let (files_list, new_alg) = crate::db::add_path_into_remote_archive(
                     &storage,
                     &archive,
@@ -347,11 +348,11 @@ impl<'a> FakeRelease<'a> {
             }
         };
 
-        tracing::debug!("before upload source");
+        debug!("before upload source");
         let source_tmp = create_temp_dir();
         store_files_into(&self.source_files, source_tmp.path())?;
         let (source_meta, algs) = upload_files(FileKind::Sources, source_tmp.path())?;
-        tracing::debug!("added source files {}", source_meta);
+        debug!("added source files {}", source_meta);
 
         // If the test didn't add custom builds, inject a default one
         if self.builds.is_empty() {
@@ -370,19 +371,19 @@ impl<'a> FakeRelease<'a> {
 
             // store default target files
             store_files_into(&rustdoc_files, rustdoc_path)?;
-            tracing::debug!("added rustdoc files");
+            debug!("added rustdoc files");
 
             for target in &package.targets[1..] {
                 let platform = target.src_path.as_ref().unwrap();
                 let platform_dir = rustdoc_path.join(platform);
                 fs::create_dir(&platform_dir)?;
 
                 store_files_into(&rustdoc_files, &platform_dir)?;
-                tracing::debug!("added platform files for {}", platform);
+                debug!("added platform files for {}", platform);
             }
 
             let (rustdoc_meta, _) = upload_files(FileKind::Rustdoc, rustdoc_path)?;
-            tracing::debug!("uploaded rustdoc files: {}", rustdoc_meta);
+            debug!("uploaded rustdoc files: {}", rustdoc_meta);
         }
 
         let repository = match self.github_stats {

src/test/mod.rs

@@ -19,7 +19,7 @@ use reqwest::{
 };
 use std::{fs, net::SocketAddr, panic, sync::Arc, time::Duration};
 use tokio::runtime::Runtime;
-use tracing::error;
+use tracing::{debug, error};
 
 #[track_caller]
 pub(crate) fn wrapper(f: impl FnOnce(&TestEnvironment) -> Result<()>) {
@@ -536,13 +536,13 @@ impl TestFrontend {
 
     pub(crate) fn get(&self, url: &str) -> RequestBuilder {
         let url = self.build_url(url);
-        tracing::debug!("getting {url}");
+        debug!("getting {url}");
         self.client.request(Method::GET, url)
     }
 
     pub(crate) fn get_no_redirect(&self, url: &str) -> RequestBuilder {
         let url = self.build_url(url);
-        tracing::debug!("getting {url} (no redirects)");
+        debug!("getting {url} (no redirects)");
         self.client_no_redirect.request(Method::GET, url)
     }
 }

src/utils/consistency/mod.rs

@@ -1,6 +1,7 @@
 use self::diff::{Diff, Diffable};
 use crate::Index;
 use anyhow::Context;
+use tracing::info;
 
 mod data;
 mod db;
@@ -16,17 +17,17 @@ pub fn run_check(
         anyhow::bail!("TODO: only a --dry-run synchronization is supported currently");
     }
 
-    tracing::info!("Loading data from database...");
+    info!("Loading data from database...");
     let timer = std::time::Instant::now();
     let db_data =
         self::db::load(conn).context("Loading crate data from database for consistency check")?;
-    tracing::info!("...loaded in {:?}", timer.elapsed());
+    info!("...loaded in {:?}", timer.elapsed());
 
     tracing::info!("Loading data from index...");
     let timer = std::time::Instant::now();
     let index_data =
         self::index::load(index).context("Loading crate data from index for consistency check")?;
-    tracing::info!("...loaded in {:?}", timer.elapsed());
+    info!("...loaded in {:?}", timer.elapsed());
 
     let diff = db_data.diff(index_data);
 

src/utils/daemon.rs

@@ -10,7 +10,7 @@ use anyhow::{anyhow, Context as _, Error};
 use std::sync::Arc;
 use std::thread;
 use std::time::{Duration, Instant};
-use tracing::{debug, info};
+use tracing::{debug, error, info};
 
 /// Run the registry watcher
 /// NOTE: this should only be run once, otherwise crates would be added
@@ -30,7 +30,7 @@ pub fn watch_registry(
         }
         Ok(None) => {}
         Err(err) => {
-            tracing::error!(
+            error!(
                 "queue locked because of invalid last_seen_index_reference in database: {:?}",
                 err
             );

src/utils/mod.rs

@@ -24,6 +24,7 @@ use anyhow::Result;
 use postgres::Client;
 use serde::de::DeserializeOwned;
 use serde::Serialize;
+use tracing::error;
 pub(crate) mod sized_buffer;
 
 pub(crate) const APP_USER_AGENT: &str = concat!(
@@ -37,7 +38,7 @@ pub(crate) fn report_error(err: &anyhow::Error) {
         sentry_anyhow::capture_anyhow(err);
     } else {
         // Debug-format for anyhow errors includes context & backtrace
-        tracing::error!("{:?}", err);
+        error!("{:?}", err);
     }
 }
 

src/web/metrics.rs

@@ -6,6 +6,8 @@ use iron::prelude::*;
 use iron::status::Status;
 use prometheus::{Encoder, HistogramVec, TextEncoder};
 use std::time::{Duration, Instant};
+#[cfg(test)]
+use tracing::debug;
 
 pub(super) fn metrics_handler(req: &mut Request) -> IronResult<Response> {
     let metrics = extension!(req, Metrics);
@@ -93,7 +95,7 @@ impl<'a> RenderingTimesRecorder<'a> {
     fn record_current(&mut self) {
         if let Some(current) = self.current.take() {
             #[cfg(test)]
-            tracing::debug!(
+            debug!(
                 "rendering time - {}: {:?}",
                 current.step,
                 current.start.elapsed()

src/web/mod.rs

@@ -363,10 +363,9 @@ fn match_version(
         VersionReq::STAR
     } else {
         VersionReq::parse(&req_version).map_err(|err| {
-            tracing::info!(
+            info!(
                 "could not parse version requirement \"{}\": {:?}",
-                req_version,
-                err
+                req_version, err
             );
             Nope::VersionNotFound
         })?

src/web/page/templates.rs

@@ -9,6 +9,7 @@ use postgres::Client;
 use serde_json::Value;
 use std::{collections::HashMap, fmt, path::PathBuf};
 use tera::{Result as TeraResult, Tera};
+use tracing::{error, trace};
 use walkdir::WalkDir;
 
 const TEMPLATES_DIRECTORY: &str = "templates";
@@ -21,13 +22,13 @@ pub(crate) struct TemplateData {
 
 impl TemplateData {
     pub(crate) fn new(conn: &mut Client) -> Result<Self> {
-        tracing::trace!("Loading templates");
+        trace!("Loading templates");
 
         let data = Self {
             templates: load_templates(conn)?,
         };
 
-        tracing::trace!("Finished loading templates");
+        trace!("Finished loading templates");
 
         Ok(data)
     }
@@ -84,7 +85,7 @@ pub(super) fn load_templates(conn: &mut Client) -> Result<Tera> {
         &mut tera,
         "rustc_resource_suffix",
         Value::String(load_rustc_resource_suffix(conn).unwrap_or_else(|err| {
-            tracing::error!("Failed to load rustc resource suffix: {:?}", err);
+            error!("Failed to load rustc resource suffix: {:?}", err);
             // This is not fatal because the server might be started before essential files are
             // generated during development. Returning "???" provides a degraded UX, but allows the
             // server to start every time.