Function default_logger 

pub fn default_logger() -> Arc<Logger>

Returns the global default logger.

This default logger will be used by logging macros, if the logger parameter is not specified when logging macros are called.

If the default logger has not been replaced, the default:

• contains a sink StdStreamSink, writing logs on Level::Info and more verbose levels to stdout.

• contains a sink StdStreamSink, writing logs on Level::Warn level and more severe levels to stderr.

• level filter ignores logs on Level::Debug and more verbose levels.

  However, if you want to enable logging for all levels:

  use spdlog::prelude::*;
  
  spdlog::default_logger().set_level_filter(LevelFilter::All);

Users can replace the default logger with set_default_logger or swap_default_logger.

Examples

use spdlog::prelude::*;

let default_logger = spdlog::default_logger();

default_logger.set_level_filter(LevelFilter::All);

info!("this log will be written to `stdout`");
debug!("this log will be written to `stdout`");
trace!("this log will be written to `stdout`");

warn!("this log will be written to `stderr`");
error!("this log will be written to `stderr`");
critical!("this log will be written to `stderr`");

Examples found in repository

examples/native/linux.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use spdlog::{prelude::*, sink::JournaldSink};

    let sink = JournaldSink::builder().build_arc()?;
    let logger = spdlog::default_logger().fork_with(|logger| {
        logger.set_name(Some("demo")).unwrap();
        logger.sinks_mut().push(sink);
        Ok(())
    })?;
    spdlog::set_default_logger(logger);

    info!("info message from spdlog-rs's JournaldSink");
    error!("error message from spdlog-rs's JournaldSink", kv: { error_code = 114514 });
    Ok(())
}

examples/04-format.rs (line 26)

fn use_pattern_formatter() {
    use spdlog::{
        formatter::{pattern, PatternFormatter},
        prelude::*,
    };

    // Building a pattern formatter with a pattern.
    // The `pattern!` macro will parse the template string at compile-time.
    let new_formatter = Box::new(PatternFormatter::new(pattern!(
        "{datetime} - {^{level}} - {payload}{eol}"
    )));

    // Setting the new formatter for each sink of the default logger.
    for sink in spdlog::default_logger().sinks() {
        sink.set_formatter(new_formatter.clone())
    }

    info!("format by `PatternFormatter`");
}

fn impl_manually() {
    use std::fmt::Write;

    use spdlog::{
        formatter::{Formatter, FormatterContext},
        prelude::*,
        Record, StringBuf,
    };

    #[derive(Clone, Default)]
    struct MyFormatter;

    impl Formatter for MyFormatter {
        fn format(
            &self,
            record: &Record,
            dest: &mut StringBuf,
            ctx: &mut FormatterContext,
        ) -> spdlog::Result<()> {
            let style_range_begin = dest.len();

            dest.write_str(&record.level().as_str().to_ascii_uppercase())
                .map_err(spdlog::Error::FormatRecord)?;

            let style_range_end = dest.len();

            writeln!(dest, " {}", record.payload()).map_err(spdlog::Error::FormatRecord)?;

            ctx.set_style_range(Some(style_range_begin..style_range_end));
            Ok(())
        }
    }

    // Building a custom formatter.
    let new_formatter = Box::new(MyFormatter);

    // Setting the new formatter for each sink of the default logger.
    for sink in spdlog::default_logger().sinks() {
        sink.set_formatter(new_formatter.clone())
    }

    info!("format by `MyFormatter` (impl manually)");
}

examples/01-macro.rs (line 18)

fn main() {
    // Writes a log at "info" level, and this log will be processed by the global
    // default logger - It will be output to `stdout`.
    info!("program started");

    // They will be output to `stderr`.
    let file = "config.json";
    error!("failed to open file: {}", file);
    warn!("undetermined locale, defaults to `en_US.UTF-8`");

    // Level "trace" and "debug" will be ignored by default, you can modify the
    // level filter of the global default logger to enable all levels.
    let verbose = true;
    if verbose {
        spdlog::default_logger().set_level_filter(LevelFilter::All);
    }

    trace!("position x: {}, y: {}", 11.4, -5.14);
    // Or if you prefer structured logging.
    trace!("position", kv: { x = 11.4, y = -5.14 });
}

examples/06-log-crate.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    spdlog::init_log_crate_proxy()
        .expect("users should only call `init_log_crate_proxy` function once");

    // Setup filter as needed.
    let filter = env_filter::Builder::new().try_parse("RUST_LOG")?.build();
    spdlog::log_crate_proxy().set_filter(Some(filter));

    log::set_max_level(log::LevelFilter::Trace);
    log::trace!("this log will be processed by the global default logger in spdlog-rs");

    let custom_logger = spdlog::default_logger().fork_with_name(Some("another_logger"))?;
    spdlog::log_crate_proxy().set_logger(Some(custom_logger));
    log::info!("this log will be processed by custom_logger in spdlog-rs");

    spdlog::log_crate_proxy().set_logger(None);
    log::trace!("this log will be processed by the global default logger in spdlog-rs");

    Ok(())
}

examples/03-logger.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // `spdlog-rs` has a global default logger and logs will be processed by it
    // by default, You can configure it.
    let default_logger = spdlog::default_logger();
    default_logger.set_level_filter(LevelFilter::All);

    // Or completely replace it with a new one.
    let path = env::current_exe()?.with_file_name("all.log");
    let file_sink = FileSink::builder().path(path).build_arc()?;

    let new_logger = Logger::builder()
        .level_filter(LevelFilter::All)
        .flush_level_filter(LevelFilter::MoreSevereEqual(Level::Warn))
        .sink(file_sink.clone())
        .build_arc()?;
    new_logger.set_flush_period(Some(Duration::from_secs(3)));
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `all.log`");

    // In addition to having the global default logger, more loggers are allowed to
    // be configured, stored and used independently.
    let db = AppDatabase::new(file_sink)?;
    db.write_i32(114514);

    Ok(())
}