Struct LoggerConfig 

pub struct LoggerConfig {
    pub policy: LogPolicy,
    pub output: LogOutputMode,
    pub file: Option<FileSinkConfig>,
    pub crash_events: usize,
    pub crash_bytes: usize,
}

Complete explicit logger configuration.

Fields

policy: LogPolicy

Filtering and sanitization policy.

output: LogOutputMode

Terminal, file, both, disabled or crash-only behavior.

file: Option<FileSinkConfig>

File configuration used by file output or an explicit crash dump.

crash_events: usize

Maximum events retained by crash-only mode.

crash_bytes: usize

Maximum estimated bytes retained by crash-only mode.

Implementations

impl LoggerConfig

pub fn build(self) -> Result<ConfiguredLogger, LogConfigError>

Builds a logger with no hidden global state or background thread.

Examples found in repository

examples/basic.rs (line 24)

fn main() -> Result<(), appcore_log::LogConfigError> {
    // Safe V4 terminal logging is explicit and creates no global state.
    let logger = LoggerConfig {
        output: LogOutputMode::Terminal,
        ..LoggerConfig::default()
    }
    .build()?;

    // The builder defaults to V4 and can be kept for related events.
    let log = logger.dispatcher().event(0, "application");

    log.info("application started");
    log.warn("connection is slower than expected");
    log.error("document could not be saved");

    Ok(())
}

examples/output_modes.rs (line 32)

fn main() -> Result<(), appcore_log::LogConfigError> {
    // Replace this with Disabled, Terminal, File, TerminalAndFile or CrashOnly.
    let output = LogOutputMode::CrashOnly;

    let logger = LoggerConfig {
        output,
        file: Some(FileSinkConfig {
            path: std::env::temp_dir().join("my-application-crash.jsonl"),
            max_bytes: LOG_SIZE_2_MIB,
            sync_each_write: true,
            retention: 1,
            archive: None,
        }),
        crash_events: 128,
        crash_bytes: 512 * 1024,
        ..LoggerConfig::default()
    }
    .build()?;

    let log = logger.dispatcher().event(0, "application");

    log.info("kept only in the bounded crash ring");

    // Call this from the application's panic/crash boundary. In every other
    // mode it is a no-op and returns zero.
    let _written_events = logger.dump_crash()?;

    Ok(())
}

examples/file_logging.rs (line 50)

fn main() -> Result<(), appcore_log::LogConfigError> {
    // Keep generated output predictable and inside Cargo's ignored target tree.
    let output_directory = PathBuf::from("target/appcore-log-example");
    std::fs::create_dir_all(&output_directory).map_err(|_| LogConfigError::Sink(LogError::Io))?;

    let active_file = output_directory.join("application.jsonl");

    // Two rotations stay beside the active file. Older rotations move into
    // archive/YYYY/MM and the complete archive never exceeds 120 files.
    let archive_directory = output_directory.join("archive");
    let mut policy = LogPolicy::new(Verbosity::V4);
    policy.set_component("sync", Verbosity::V8);

    let logger = LoggerConfig {
        policy,
        output: LogOutputMode::TerminalAndFile,
        file: Some(FileSinkConfig {
            path: active_file,
            max_bytes: LOG_SIZE_8_MIB,
            sync_each_write: false,
            retention: 2,
            archive: Some(FileArchiveConfig {
                directory: archive_directory,
                max_files: 120,
            }),
        }),
        ..LoggerConfig::default()
    }
    .build()?;

    let application = logger.dispatcher().event(0, "application");
    let sync = logger.dispatcher().event(1, "sync.transport");

    application.info("application ready; inspect target/appcore-log-example/application.jsonl");

    // The parent component policy makes this V7 diagnostic visible.
    sync.verbosity(7).debug("replication batch sent");

    sync.warn("peer response was delayed");

    let stats = logger.dispatcher().stats();
    assert_eq!(stats.sink_failures, 0);

    Ok(())
}

Trait Implementations

impl Clone for LoggerConfig

fn clone(&self) -> LoggerConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LoggerConfig

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

Formats the value using the given formatter.

impl Default for LoggerConfig

fn default() -> Self

Returns the “default value” for a type.