Struct LoggerConfigBuilder

pub struct LoggerConfigBuilder { /* private fields */ }

Builder for constructing a LoggerConfig using a fluent API.

This follows the builder pattern to provide a clean way to create custom logger configurations.

Example

use fstdout_logger::LoggerConfigBuilder;
use log::LevelFilter;

let config = LoggerConfigBuilder::default()
    .level(LevelFilter::Warn)
    .show_file_info(true)
    .show_date_in_stdout(true)
    .use_colors(false)
    .build();

Implementations

impl LoggerConfigBuilder

pub fn show_file_info(self, show: bool) -> Self

Set whether to show file and line information in log messages.

When enabled, each log message will include the source file and line number where the log was created. This is useful for debugging but can make logs more verbose for production use.

Default: true

Examples found in repository

examples/stdout_only.rs (line 17)

fn main() {
    // Initialize logger with stdout only (no file output) with colors
    let config = LoggerConfig::builder()
        .level(LevelFilter::Debug) // Show Debug level and above
        .show_file_info(false) // Don't show file and line information
        .use_colors(true) // Use colors in output
        .build();

    if let Err(e) = init_stdout_logger(config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Output will only appear on stdout.");
    println!("Notice that TRACE level messages won't show because we set Debug as minimum level.");
    println!("Also note that file and line information is hidden for cleaner output.");

    // Log messages at different levels to demonstrate filtering
    trace!("This is a TRACE message - you won't see this");
    debug!("This is a DEBUG message - visible");
    info!("This is an INFO message - visible");
    warn!("This is a WARNING message - visible");
    error!("This is an ERROR message - visible");

    // Log messages with dynamic content
    for i in 1..=3 {
        let value = i * 10;
        debug!("Debug calculation: {i} * 10 = {value}");
        info!("Processing item #{i} with value {value}");
    }

    info!("Example completed");
}

examples/basic_usage.rs (line 23)

fn main() {
    // Initialize logger with file output and colored stdout
    let log_path = "application.log";

    // Create a custom configuration with the builder pattern
    // This shows how to configure every aspect of the logger
    let config = LoggerConfig::builder()
        .level(LevelFilter::Trace) // Show all log levels, including TRACE
        .show_file_info(true) // Include file and line info in logs
        .show_date_in_stdout(false) // Only show time (HH:MM:SS) in console output
        .use_colors(true) // Use colors for different log levels
        .build();

    if let Err(e) = init_logger_with_config(Some(log_path), config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Check {log_path} for log output.");
    println!("Log messages will appear both on stdout and in the log file.");
    println!("Notice that stdout logs show time only while the file includes dates.");

    // Log messages at different levels to demonstrate the hierarchy
    // All of these will appear because we set level to Trace
    trace!("This is a TRACE message"); // Lowest level, normally hidden
    debug!("This is a DEBUG message"); // For developer information
    info!("This is an INFO message"); // Normal application events
    warn!("This is a WARNING message"); // Important but non-critical issues
    error!("This is an ERROR message"); // Critical issues that need attention

    // Simulate some application activity
    for i in 1..=5 {
        info!("Application is running... iteration {i}");
        sleep(Duration::from_millis(500));
    }

    // Log a final message
    info!("Application finished successfully");

    println!("\nAfter running this example, check the 'application.log' file");
    println!("to see how logs are formatted differently for file output.");
}

pub fn show_date_in_stdout(self, show: bool) -> Self

Set whether to show date in stdout logs.

When enabled, stdout logs will include the full date (YYYY-MM-DD). When disabled, only the time (HH:MM:SS) will be shown. Note: Log files always include the full date regardless of this setting.

Default: false

Examples found in repository

examples/basic_usage.rs (line 24)

fn main() {
    // Initialize logger with file output and colored stdout
    let log_path = "application.log";

    // Create a custom configuration with the builder pattern
    // This shows how to configure every aspect of the logger
    let config = LoggerConfig::builder()
        .level(LevelFilter::Trace) // Show all log levels, including TRACE
        .show_file_info(true) // Include file and line info in logs
        .show_date_in_stdout(false) // Only show time (HH:MM:SS) in console output
        .use_colors(true) // Use colors for different log levels
        .build();

    if let Err(e) = init_logger_with_config(Some(log_path), config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Check {log_path} for log output.");
    println!("Log messages will appear both on stdout and in the log file.");
    println!("Notice that stdout logs show time only while the file includes dates.");

    // Log messages at different levels to demonstrate the hierarchy
    // All of these will appear because we set level to Trace
    trace!("This is a TRACE message"); // Lowest level, normally hidden
    debug!("This is a DEBUG message"); // For developer information
    info!("This is an INFO message"); // Normal application events
    warn!("This is a WARNING message"); // Important but non-critical issues
    error!("This is an ERROR message"); // Critical issues that need attention

    // Simulate some application activity
    for i in 1..=5 {
        info!("Application is running... iteration {i}");
        sleep(Duration::from_millis(500));
    }

    // Log a final message
    info!("Application finished successfully");

    println!("\nAfter running this example, check the 'application.log' file");
    println!("to see how logs are formatted differently for file output.");
}

pub fn use_colors(self, use_colors: bool) -> Self

Set whether to use colors in stdout logs.

When enabled, different log levels will be displayed in different colors:

• ERROR: Red
• WARN: Yellow
• INFO: Blue
• DEBUG: Green
• TRACE: Default terminal color

Note: Log files never include color codes regardless of this setting.

Default: true

Examples found in repository

examples/stdout_only.rs (line 18)

fn main() {
    // Initialize logger with stdout only (no file output) with colors
    let config = LoggerConfig::builder()
        .level(LevelFilter::Debug) // Show Debug level and above
        .show_file_info(false) // Don't show file and line information
        .use_colors(true) // Use colors in output
        .build();

    if let Err(e) = init_stdout_logger(config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Output will only appear on stdout.");
    println!("Notice that TRACE level messages won't show because we set Debug as minimum level.");
    println!("Also note that file and line information is hidden for cleaner output.");

    // Log messages at different levels to demonstrate filtering
    trace!("This is a TRACE message - you won't see this");
    debug!("This is a DEBUG message - visible");
    info!("This is an INFO message - visible");
    warn!("This is a WARNING message - visible");
    error!("This is an ERROR message - visible");

    // Log messages with dynamic content
    for i in 1..=3 {
        let value = i * 10;
        debug!("Debug calculation: {i} * 10 = {value}");
        info!("Processing item #{i} with value {value}");
    }

    info!("Example completed");
}

examples/basic_usage.rs (line 25)

fn main() {
    // Initialize logger with file output and colored stdout
    let log_path = "application.log";

    // Create a custom configuration with the builder pattern
    // This shows how to configure every aspect of the logger
    let config = LoggerConfig::builder()
        .level(LevelFilter::Trace) // Show all log levels, including TRACE
        .show_file_info(true) // Include file and line info in logs
        .show_date_in_stdout(false) // Only show time (HH:MM:SS) in console output
        .use_colors(true) // Use colors for different log levels
        .build();

    if let Err(e) = init_logger_with_config(Some(log_path), config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Check {log_path} for log output.");
    println!("Log messages will appear both on stdout and in the log file.");
    println!("Notice that stdout logs show time only while the file includes dates.");

    // Log messages at different levels to demonstrate the hierarchy
    // All of these will appear because we set level to Trace
    trace!("This is a TRACE message"); // Lowest level, normally hidden
    debug!("This is a DEBUG message"); // For developer information
    info!("This is an INFO message"); // Normal application events
    warn!("This is a WARNING message"); // Important but non-critical issues
    error!("This is an ERROR message"); // Critical issues that need attention

    // Simulate some application activity
    for i in 1..=5 {
        info!("Application is running... iteration {i}");
        sleep(Duration::from_millis(500));
    }

    // Log a final message
    info!("Application finished successfully");

    println!("\nAfter running this example, check the 'application.log' file");
    println!("to see how logs are formatted differently for file output.");
}

pub fn level(self, level: LevelFilter) -> Self

Set the minimum log level to display.

This filters log messages based on their level:

• Error: Only errors
• Warn: Errors and warnings
• Info: Errors, warnings, and info
• Debug: Errors, warnings, info, and debug
• Trace: All log levels

Default: Info

Examples found in repository

examples/stdout_only.rs (line 16)

fn main() {
    // Initialize logger with stdout only (no file output) with colors
    let config = LoggerConfig::builder()
        .level(LevelFilter::Debug) // Show Debug level and above
        .show_file_info(false) // Don't show file and line information
        .use_colors(true) // Use colors in output
        .build();

    if let Err(e) = init_stdout_logger(config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Output will only appear on stdout.");
    println!("Notice that TRACE level messages won't show because we set Debug as minimum level.");
    println!("Also note that file and line information is hidden for cleaner output.");

    // Log messages at different levels to demonstrate filtering
    trace!("This is a TRACE message - you won't see this");
    debug!("This is a DEBUG message - visible");
    info!("This is an INFO message - visible");
    warn!("This is a WARNING message - visible");
    error!("This is an ERROR message - visible");

    // Log messages with dynamic content
    for i in 1..=3 {
        let value = i * 10;
        debug!("Debug calculation: {i} * 10 = {value}");
        info!("Processing item #{i} with value {value}");
    }

    info!("Example completed");
}

examples/basic_usage.rs (line 22)

fn main() {
    // Initialize logger with file output and colored stdout
    let log_path = "application.log";

    // Create a custom configuration with the builder pattern
    // This shows how to configure every aspect of the logger
    let config = LoggerConfig::builder()
        .level(LevelFilter::Trace) // Show all log levels, including TRACE
        .show_file_info(true) // Include file and line info in logs
        .show_date_in_stdout(false) // Only show time (HH:MM:SS) in console output
        .use_colors(true) // Use colors for different log levels
        .build();

    if let Err(e) = init_logger_with_config(Some(log_path), config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Check {log_path} for log output.");
    println!("Log messages will appear both on stdout and in the log file.");
    println!("Notice that stdout logs show time only while the file includes dates.");

    // Log messages at different levels to demonstrate the hierarchy
    // All of these will appear because we set level to Trace
    trace!("This is a TRACE message"); // Lowest level, normally hidden
    debug!("This is a DEBUG message"); // For developer information
    info!("This is an INFO message"); // Normal application events
    warn!("This is a WARNING message"); // Important but non-critical issues
    error!("This is an ERROR message"); // Critical issues that need attention

    // Simulate some application activity
    for i in 1..=5 {
        info!("Application is running... iteration {i}");
        sleep(Duration::from_millis(500));
    }

    // Log a final message
    info!("Application finished successfully");

    println!("\nAfter running this example, check the 'application.log' file");
    println!("to see how logs are formatted differently for file output.");
}

pub fn build(self) -> LoggerConfig

Build the final configuration.

This consumes the builder and returns a LoggerConfig.

Examples found in repository

examples/stdout_only.rs (line 19)

fn main() {
    // Initialize logger with stdout only (no file output) with colors
    let config = LoggerConfig::builder()
        .level(LevelFilter::Debug) // Show Debug level and above
        .show_file_info(false) // Don't show file and line information
        .use_colors(true) // Use colors in output
        .build();

    if let Err(e) = init_stdout_logger(config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Output will only appear on stdout.");
    println!("Notice that TRACE level messages won't show because we set Debug as minimum level.");
    println!("Also note that file and line information is hidden for cleaner output.");

    // Log messages at different levels to demonstrate filtering
    trace!("This is a TRACE message - you won't see this");
    debug!("This is a DEBUG message - visible");
    info!("This is an INFO message - visible");
    warn!("This is a WARNING message - visible");
    error!("This is an ERROR message - visible");

    // Log messages with dynamic content
    for i in 1..=3 {
        let value = i * 10;
        debug!("Debug calculation: {i} * 10 = {value}");
        info!("Processing item #{i} with value {value}");
    }

    info!("Example completed");
}

examples/basic_usage.rs (line 26)

fn main() {
    // Initialize logger with file output and colored stdout
    let log_path = "application.log";

    // Create a custom configuration with the builder pattern
    // This shows how to configure every aspect of the logger
    let config = LoggerConfig::builder()
        .level(LevelFilter::Trace) // Show all log levels, including TRACE
        .show_file_info(true) // Include file and line info in logs
        .show_date_in_stdout(false) // Only show time (HH:MM:SS) in console output
        .use_colors(true) // Use colors for different log levels
        .build();

    if let Err(e) = init_logger_with_config(Some(log_path), config) {
        eprintln!("Failed to initialize logger: {e}");
        return;
    }

    println!("Logger initialized! Check {log_path} for log output.");
    println!("Log messages will appear both on stdout and in the log file.");
    println!("Notice that stdout logs show time only while the file includes dates.");

    // Log messages at different levels to demonstrate the hierarchy
    // All of these will appear because we set level to Trace
    trace!("This is a TRACE message"); // Lowest level, normally hidden
    debug!("This is a DEBUG message"); // For developer information
    info!("This is an INFO message"); // Normal application events
    warn!("This is a WARNING message"); // Important but non-critical issues
    error!("This is an ERROR message"); // Critical issues that need attention

    // Simulate some application activity
    for i in 1..=5 {
        info!("Application is running... iteration {i}");
        sleep(Duration::from_millis(500));
    }

    // Log a final message
    info!("Application finished successfully");

    println!("\nAfter running this example, check the 'application.log' file");
    println!("to see how logs are formatted differently for file output.");
}

Trait Implementations

impl Debug for LoggerConfigBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LoggerConfigBuilder

fn default() -> LoggerConfigBuilder

Returns the “default value” for a type.