Add logging utils to common crate

Author: aecsocket

Cargo.lock

@@ -37,7 +37,6 @@ clap = { workspace = true, features = ["derive"] }
 clickhouse = { workspace = true, features = ["time", "uuid"] }
 color-eyre = { workspace = true }
 color-thief = { workspace = true }
-console-subscriber = { workspace = true }
 const_format = { workspace = true }
 dashmap = { workspace = true }
 deadpool-redis.workspace = true
@@ -72,6 +71,7 @@ json-patch = { workspace = true }
 lettre = { workspace = true }
 meilisearch-sdk = { workspace = true, features = ["reqwest"] }
 modrinth-maxmind = { workspace = true }
+modrinth-util = { workspace = true }
 muralpay = { workspace = true, features = ["utoipa"] }
 murmur2 = { workspace = true }
 paste = { workspace = true }
@@ -120,8 +120,6 @@ tokio-stream = { workspace = true }
 totp-rs = { workspace = true, features = ["gen_secret"] }
 tracing = { workspace = true }
 tracing-actix-web = { workspace = true }
-tracing-ecs = { workspace = true }
-tracing-subscriber = { workspace = true }
 url = { workspace = true }
 urlencoding = { workspace = true }
 utoipa = { workspace = true }

apps/labrinth/Cargo.toml

@@ -19,13 +19,8 @@ use labrinth::{check_env_vars, clickhouse, database, file_hosting};
 use std::ffi::CStr;
 use std::str::FromStr;
 use std::sync::Arc;
-use tracing::level_filters::LevelFilter;
 use tracing::{Instrument, error, info, info_span};
 use tracing_actix_web::TracingLogger;
-use tracing_ecs::ECSLayerBuilder;
-use tracing_subscriber::EnvFilter;
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::util::SubscriberInitExt;
 use utoipa::OpenApi;
 use utoipa_actix_web::AppExt;
 use utoipa_swagger_ui::SwaggerUi;
@@ -59,59 +54,13 @@ struct Args {
     run_background_task: Option<BackgroundTask>,
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-enum OutputFormat {
-    #[default]
-    Human,
-    Json,
-}
-
-impl FromStr for OutputFormat {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "human" => Ok(Self::Human),
-            "json" => Ok(Self::Json),
-            _ => Err(()),
-        }
-    }
-}
-
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
     let args = Args::parse();
 
     color_eyre::install().expect("failed to install `color-eyre`");
     dotenvy::dotenv().ok();
-    let console_layer = console_subscriber::spawn();
-    let env_filter = EnvFilter::builder()
-        .with_default_directive(LevelFilter::INFO.into())
-        .from_env_lossy();
-
-    let output_format =
-        dotenvy::var("LABRINTH_FORMAT").map_or(OutputFormat::Human, |format| {
-            format
-                .parse::<OutputFormat>()
-                .unwrap_or_else(|_| panic!("invalid output format '{format}'"))
-        });
-
-    match output_format {
-        OutputFormat::Human => {
-            tracing_subscriber::registry()
-                .with(console_layer)
-                .with(env_filter)
-                .with(tracing_subscriber::fmt::layer())
-                .init();
-        }
-        OutputFormat::Json => {
-            tracing_subscriber::registry()
-                .with(console_layer)
-                .with(env_filter)
-                .with(ECSLayerBuilder::default().stdout())
-                .init();
-        }
-    }
+    modrinth_util::log::init().expect("failed to initialize logging");
 
     if check_env_vars() {
         error!("Some environment variables are missing!");

apps/labrinth/src/main.rs

@@ -6,10 +6,14 @@ repository.workspace = true
 
 [dependencies]
 actix-web = { workspace = true }
+console-subscriber = { workspace = true }
 derive_more = { workspace = true, features = ["display", "error", "from"] }
 dotenvy = { workspace = true }
 eyre = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+tracing = { workspace = true }
+tracing-ecs = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [lints]
 workspace = true

packages/modrinth-util/Cargo.toml

@@ -1,6 +1,8 @@
 #![doc = include_str!("../README.md")]
 
 mod error;
+pub mod log;
+
 pub use error::*;
 
 use eyre::{Result, eyre};

packages/modrinth-util/src/lib.rs

@@ -0,0 +1,77 @@
+//! Service logging utilities.
+
+use std::str::FromStr;
+
+use eyre::{Result, eyre};
+use tracing::level_filters::LevelFilter;
+use tracing_ecs::ECSLayerBuilder;
+use tracing_subscriber::{
+    EnvFilter, layer::SubscriberExt, util::SubscriberInitExt,
+};
+
+use crate::{Context, env_var};
+
+/// How this service will output logs to the terminal output.
+///
+/// See [`init`].
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+enum OutputFormat {
+    /// Human-readable format using [`tracing_subscriber::fmt::layer`].
+    #[default]
+    Human,
+    /// Elastic Common Schema JSON output using [`ECSLayerBuilder`].
+    Json,
+}
+
+impl FromStr for OutputFormat {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "human" => Ok(Self::Human),
+            "json" => Ok(Self::Json),
+            _ => Err(()),
+        }
+    }
+}
+
+/// Key for the environment variable that determines the output format.
+pub const OUTPUT_FORMAT_ENV_VAR: &str = "MODRINTH_OUTPUT_FORMAT";
+
+/// Initializes logging for Modrinth services.
+///
+/// This uses [`OUTPUT_FORMAT_ENV_VAR`] to determine the [`OutputFormat`] to
+/// use - see that type for details of each possible format.
+///
+/// # Errors
+///
+/// Errors if logging could not be initialized.
+pub fn init() -> Result<()> {
+    let output_format = match env_var(OUTPUT_FORMAT_ENV_VAR) {
+        Ok(format) => format
+            .parse::<OutputFormat>()
+            .map_err(|_| eyre!("invalid output format '{format}'"))?,
+        Err(_) => OutputFormat::Human,
+    };
+
+    let console_layer = console_subscriber::spawn();
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(LevelFilter::INFO.into())
+        .from_env_lossy();
+
+    let result = match output_format {
+        OutputFormat::Human => tracing_subscriber::registry()
+            .with(console_layer)
+            .with(env_filter)
+            .with(tracing_subscriber::fmt::layer())
+            .try_init(),
+        OutputFormat::Json => tracing_subscriber::registry()
+            .with(console_layer)
+            .with(env_filter)
+            .with(ECSLayerBuilder::default().stdout())
+            .try_init(),
+    };
+    result.wrap_err("failed to initialize tracing registry")?;
+
+    Ok(())
+}