Move from log to tracing crate

Cargo.toml

@@ -96,6 +96,7 @@ tracing = "0.1.40"
 url = { version = "2.5.0", features = ["serde"] }
 urlencoding = "2"
 uuid = { version = "1", features = ["v4"] }
+tracing-subscriber = { version = "0.3.18", features = ["json"] }
 
 [dev-dependencies]
 tempfile = "3"

packages/located-error/Cargo.toml

@@ -15,7 +15,8 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-log = { version = "0", features = ["release_max_level_info"] }
+tracing = "0.1.40"
+tracing-subscriber = { version = "0.3.18", features = ["json"] }
 
 [dev-dependencies]
 thiserror = "1.0"

packages/located-error/src/lib.rs

@@ -90,7 +90,7 @@ where
             source: Arc::new(self.0),
             location: Box::new(*std::panic::Location::caller()),
         };
-        log::debug!("{e}");
+        tracing::debug!("{e}");
         e
     }
 }

src/bootstrap/logging.rs

@@ -8,55 +8,73 @@
 //! - `Trace`
 use std::sync::Once;
 
-use log::{info, LevelFilter};
+use tracing::info;
+use tracing::level_filters::LevelFilter;
 
 use crate::config::v1::LogLevel;
 
 static INIT: Once = Once::new();
 
 pub fn setup(log_level: &Option<LogLevel>) {
-    let level = config_level_or_default(log_level);
+    let tracing_level = config_level_or_default(log_level);
 
-    if level == log::LevelFilter::Off {
+    if tracing_level == LevelFilter::OFF {
         return;
     }
 
     INIT.call_once(|| {
-        stdout_config(level);
+        tracing_stdout_init(tracing_level, &TraceStyle::Default);
     });
 }
 
 fn config_level_or_default(log_level: &Option<LogLevel>) -> LevelFilter {
     match log_level {
-        None => log::LevelFilter::Info,
+        None => LevelFilter::INFO,
         Some(level) => match level {
-            LogLevel::Off => LevelFilter::Off,
-            LogLevel::Error => LevelFilter::Error,
-            LogLevel::Warn => LevelFilter::Warn,
-            LogLevel::Info => LevelFilter::Info,
-            LogLevel::Debug => LevelFilter::Debug,
-            LogLevel::Trace => LevelFilter::Trace,
+            LogLevel::Off => LevelFilter::OFF,
+            LogLevel::Error => LevelFilter::ERROR,
+            LogLevel::Warn => LevelFilter::WARN,
+            LogLevel::Info => LevelFilter::INFO,
+            LogLevel::Debug => LevelFilter::DEBUG,
+            LogLevel::Trace => LevelFilter::TRACE,
         },
     }
 }
 
-fn stdout_config(level: LevelFilter) {
-    if let Err(_err) = fern::Dispatch::new()
-        .format(|out, message, record| {
-            out.finish(format_args!(
-                "{} [{}][{}] {}",
-                chrono::Local::now().format("%+"),
-                record.target(),
-                record.level(),
-                message
-            ));
-        })
-        .level(level)
-        .chain(std::io::stdout())
-        .apply()
-    {
-        panic!("Failed to initialize logging.")
-    }
+fn tracing_stdout_init(filter: LevelFilter, style: &TraceStyle) {
+    let builder = tracing_subscriber::fmt().with_max_level(filter);
+
+    let () = match style {
+        TraceStyle::Default => builder.init(),
+        TraceStyle::Pretty(display_filename) => builder.pretty().with_file(*display_filename).init(),
+        TraceStyle::Compact => builder.compact().init(),
+        TraceStyle::Json => builder.json().init(),
+    };
 
     info!("logging initialized.");
 }
+
+#[derive(Debug)]
+pub enum TraceStyle {
+    Default,
+    Pretty(bool),
+    Compact,
+    Json,
+}
+
+impl std::fmt::Display for TraceStyle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let style = match self {
+            TraceStyle::Default => "Default Style",
+            TraceStyle::Pretty(path) => match path {
+                true => "Pretty Style with File Paths",
+                false => "Pretty Style without File Paths",
+            },
+
+            TraceStyle::Compact => "Compact Style",
+            TraceStyle::Json => "Json Format",
+        };
+
+        f.write_str(style)
+    }
+}

src/console/commands/seeder/api.rs

@@ -1,6 +1,6 @@
 //! Action that a user can perform on a Index website.
-use log::debug;
 use thiserror::Error;
+use tracing::debug;
 
 use crate::web::api::client::v1::client::Client;
 use crate::web::api::client::v1::contexts::category::forms::AddCategoryForm;

src/console/commands/seeder/app.rs

@@ -133,9 +133,10 @@ use std::time::Duration;
 
 use anyhow::Context;
 use clap::Parser;
-use log::{debug, info, LevelFilter};
 use reqwest::Url;
 use text_colorizer::Colorize;
+use tracing::level_filters::LevelFilter;
+use tracing::{debug, info};
 use uuid::Uuid;
 
 use super::api::Error;
@@ -171,7 +172,7 @@ struct Args {
 ///
 /// Will not return any errors for the time being.
 pub async fn run() -> anyhow::Result<()> {
-    logging::setup(LevelFilter::Info);
+    logging::setup(LevelFilter::INFO);
 
     let args = Args::parse();
 

src/console/commands/seeder/logging.rs

@@ -1,26 +1,12 @@
 //! Logging setup for the `seeder`.
-use log::{debug, LevelFilter};
+use tracing::debug;
+use tracing::level_filters::LevelFilter;
 
 /// # Panics
 ///
 ///
 pub fn setup(level: LevelFilter) {
-    if let Err(_err) = fern::Dispatch::new()
-        .format(|out, message, record| {
-            out.finish(format_args!(
-                "{} [{}][{}] {}",
-                chrono::Local::now().format("%+"),
-                record.target(),
-                record.level(),
-                message
-            ));
-        })
-        .level(level)
-        .chain(std::io::stdout())
-        .apply()
-    {
-        panic!("Failed to initialize logging.")
-    }
+    tracing_subscriber::fmt().with_max_level(level).init();
 
     debug!("logging initialized.");
 }

src/console/cronjobs/tracker_statistics_importer.rs

@@ -17,11 +17,11 @@ use axum::extract::State;
 use axum::routing::{get, post};
 use axum::{Json, Router};
 use chrono::{DateTime, Utc};
-use log::{debug, error, info};
 use serde_json::{json, Value};
 use text_colorizer::Colorize;
 use tokio::net::TcpListener;
 use tokio::task::JoinHandle;
+use tracing::{debug, error, info};
 
 use crate::tracker::statistics_importer::StatisticsImporter;
 use crate::utils::clock::seconds_ago_utc;

src/databases/mysql.rs

@@ -509,7 +509,7 @@ impl Database for Mysql {
         .map(|v| i64::try_from(v.last_insert_id()).expect("last ID is larger than i64"))
         .map_err(|e| match e {
             sqlx::Error::Database(err) => {
-                log::error!("DB error: {:?}", err);
+                tracing::error!("DB error: {:?}", err);
                 if err.message().contains("Duplicate entry") && err.message().contains("info_hash") {
                     database::Error::TorrentAlreadyExists
                 } else {
@@ -530,7 +530,7 @@ impl Database for Mysql {
                 .await
                 .map(|_| ())
                 .map_err(|err| {
-                    log::error!("DB error: {:?}", err);
+                    tracing::error!("DB error: {:?}", err);
                     database::Error::Error
                 });
 
@@ -683,7 +683,7 @@ impl Database for Mysql {
                 .await
                 .map_err(|e| match e {
                     sqlx::Error::Database(err) => {
-                        log::error!("DB error: {:?}", err);
+                        tracing::error!("DB error: {:?}", err);
                         if err.message().contains("Duplicate entry") && err.message().contains("title") {
                             database::Error::TorrentTitleAlreadyExists
                         } else {
@@ -931,7 +931,7 @@ impl Database for Mysql {
             .await
             .map_err(|e| match e {
                 sqlx::Error::Database(err) => {
-                    log::error!("DB error: {:?}", err);
+                    tracing::error!("DB error: {:?}", err);
                     if err.message().contains("Duplicate entry") && err.message().contains("title") {
                         database::Error::TorrentTitleAlreadyExists
                     } else {
@@ -989,7 +989,7 @@ impl Database for Mysql {
             .map(|v| i64::try_from(v.last_insert_id()).expect("last ID is larger than i64"))
             .map_err(|e| match e {
                 sqlx::Error::Database(err) => {
-                    log::error!("DB error: {:?}", err);
+                    tracing::error!("DB error: {:?}", err);
                     if err.message().contains("Duplicate entry") && err.message().contains("name") {
                         database::Error::TagAlreadyExists
                     } else {