Skip to main content

forest/cli_shared/logger/
mod.rs

1// Copyright 2019-2026 ChainSafe Systems
2// SPDX-License-Identifier: Apache-2.0, MIT
3
4use std::pin::Pin;
5
6use futures::Future;
7use tracing_subscriber::{EnvFilter, Registry, prelude::*};
8
9use crate::cli_shared::cli::CliOpts;
10use crate::utils::misc::LoggingColor;
11
12type BackgroundTask = Pin<Box<dyn Future<Output = ()> + Send>>;
13
14#[allow(unused_mut)]
15pub fn setup_logger(opts: &CliOpts) -> Vec<BackgroundTask> {
16    let mut background_tasks: Vec<BackgroundTask> = vec![];
17    let mut layers: Vec<Box<dyn tracing_subscriber::layer::Layer<Registry> + Send + Sync>> =
18        // console logger
19        vec![Box::new(
20            tracing_subscriber::fmt::Layer::new()
21                .with_ansi(opts.color.coloring_enabled())
22                .with_filter(get_env_filter(default_env_filter())),
23        )];
24
25    // file logger
26    if let Some(log_dir) = &opts.log_dir {
27        let file_appender = tracing_appender::rolling::hourly(log_dir, "forest.log");
28        layers.push(Box::new(
29            tracing_subscriber::fmt::Layer::new()
30                .with_ansi(false)
31                .with_writer(file_appender)
32                .with_filter(get_env_filter(default_env_filter())),
33        ));
34    }
35
36    if opts.tokio_console {
37        #[cfg(not(feature = "tokio-console"))]
38        tracing::warn!(
39            "`tokio-console` is unavailable, forest binaries need to be recompiled with `tokio-console` feature"
40        );
41
42        #[cfg(feature = "tokio-console")]
43        layers.push(Box::new(
44            console_subscriber::ConsoleLayer::builder()
45                .with_default_env()
46                .spawn(),
47        ));
48    }
49
50    if opts.loki {
51        #[cfg(not(feature = "tracing-loki"))]
52        tracing::warn!(
53            "`tracing-loki` is unavailable, forest binaries need to be recompiled with `tracing-loki` feature"
54        );
55
56        #[cfg(feature = "tracing-loki")]
57        {
58            let (layer, task) = tracing_loki::layer(
59                tracing_loki::url::Url::parse(&opts.loki_endpoint)
60                    .map_err(|e| {
61                        format!("Unable to parse loki endpoint {}: {e}", &opts.loki_endpoint)
62                    })
63                    .unwrap(),
64                vec![(
65                    "host".into(),
66                    gethostname::gethostname()
67                        .to_str()
68                        .unwrap_or_default()
69                        .into(),
70                )]
71                .into_iter()
72                .collect(),
73                Default::default(),
74            )
75            .map_err(|e| format!("Unable to create loki layer: {e}"))
76            .unwrap();
77            background_tasks.push(Box::pin(task));
78            layers.push(Box::new(
79                layer.with_filter(tracing_subscriber::filter::LevelFilter::INFO),
80            ));
81        }
82    }
83
84    tracing_subscriber::registry().with(layers).init();
85    background_tasks
86}
87
88// Log warnings to stderr
89pub fn setup_minimal_logger() {
90    tracing_subscriber::registry()
91        .with(
92            tracing_subscriber::fmt::Layer::new()
93                .with_ansi(LoggingColor::Auto.coloring_enabled())
94                .with_writer(std::io::stderr)
95                .with_filter(get_env_filter(default_tool_filter())),
96        )
97        .init();
98}
99
100/// Returns an [`EnvFilter`] according to the `RUST_LOG` environment variable, or a default
101/// - see [`default_env_filter`] and [`default_tool_filter`]
102///
103/// Note that [`tracing_subscriber::filter::Builder`] only allows a single default directive,
104/// whereas we want to provide multiple.
105/// See also <https://github.com/tokio-rs/tracing/blob/27f688efb72316a26f3ec1f952c82626692c08ff/tracing-subscriber/src/filter/env/builder.rs#L189-L194>
106fn get_env_filter(def: EnvFilter) -> EnvFilter {
107    use std::env::{
108        self,
109        VarError::{NotPresent, NotUnicode},
110    };
111    match env::var(tracing_subscriber::EnvFilter::DEFAULT_ENV) {
112        Ok(s) => EnvFilter::new(s),
113        Err(NotPresent) => def,
114        Err(NotUnicode(_)) => EnvFilter::default(),
115    }
116}
117
118fn default_env_filter() -> EnvFilter {
119    let default_directives = [
120        "info",
121        "bellperson::groth16::aggregate::verify=warn",
122        "axum=warn",
123        "filecoin_proofs=warn",
124        "libp2p_bitswap=off",
125        "libp2p_gossipsub=error",
126        "libp2p_kad=error",
127        "storage_proofs_core=warn",
128        "tracing_loki=off",
129        "quinn_udp=error",
130    ];
131    EnvFilter::try_new(default_directives.join(",")).unwrap()
132}
133
134fn default_tool_filter() -> EnvFilter {
135    let default_directives = [
136        "info",
137        "bellperson::groth16::aggregate::verify=warn",
138        "storage_proofs_core=warn",
139        "axum=warn",
140        "filecoin_proofs=warn",
141        "forest::snapshot=info",
142        "forest::progress=info",
143        "libp2p_bitswap=off",
144        "tracing_loki=off",
145        "hickory_resolver::hosts=off",
146        "libp2p_swarm=off",
147    ];
148    EnvFilter::try_new(default_directives.join(",")).unwrap()
149}
150
151#[test]
152fn test_default_env_filter() {
153    let _did_not_panic = default_env_filter();
154}