Logging in Rust

Logging is a crucial aspect of software development, allowing programs to record events, status information, and error messages during their execution. This data is invaluable for debugging, monitoring application health, understanding program flow, auditing, and post-mortem analysis.

In Rust, logging is typically handled through a two-tiered system:
1. The `log` crate (Facade): This crate provides a lightweight logging API (macros like `info!`, `warn!`, `error!`, `debug!`, `trace!`, and `log!`). It acts as a facade, meaning it defines the interface for logging but doesn't actually perform the logging itself. Instead, it dispatches log records to an underlying logging implementation. This design allows libraries to use a common logging interface without dictating the specific logging backend their users must employ.
2. Logger Backends (Implementations): These are separate crates that implement the `log::Log` trait and process the log records received from the `log` facade. Examples include:
* `env_logger`: A popular simple logger that prints to `stderr` and is configured via environment variables (e.g., `RUST_LOG`).
* `simple_logger`: Another straightforward logger, often used for quick setup.
* `fern`: A highly configurable, flexible logging backend.
* `tracing`: A more advanced framework for instrumentation, tracing, and logging, often considered a successor or alternative to `log` for complex applications.

Key Concepts:
* Log Levels: Logging frameworks typically define several levels of severity, allowing developers to categorize messages. Common levels, in order of increasing severity, are:
* `Trace`: Very fine-grained diagnostic information, typically not for production.
* `Debug`: Detailed information useful for debugging.
* `Info`: General progress of the application, often useful for understanding general operation.
* `Warn`: Potentially harmful situations or unexpected events that might indicate a problem.
* `Error`: Serious problems that prevent parts of the application from functioning correctly.
* Initialization: For any log messages to appear, a logger backend *must* be initialized at the start of your application. If no backend is initialized, all `log!` macros will effectively become no-ops.
* Configuration: Backends often allow configuration of log levels (e.g., show only `INFO` and above, or `DEBUG` for specific modules), output formats, and destinations (e.g., console, file, network).

By using the `log` facade, applications and libraries can remain decoupled from specific logging implementations, making them more flexible and easier to integrate into different environments.

```toml
# Cargo.toml
[package]
name = "rust_logging_example"
version = "0.1.0"
edition = "2021"

[dependencies]
log = "0.4"
env_logger = "0.10"
```

```rust
// main.rs
// Import logging macros
use log::{info, warn, error, debug, trace};

fn main() {
    // 1. Initialize the logger backend.
    // env_logger is configured via environment variables, e.g., RUST_LOG=info
    // The Builder::from_env().init() approach allows setting a default filter 
    // (e.g., "info") if RUST_LOG is not explicitly set in the environment.
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info"))
        .init();

    info!("Application started successfully!");

    let user_name = "Alice";
    debug!("Processing request for user: {}", user_name);

    let items_in_stock = 5;
    if items_in_stock < 10 {
        warn!("Low stock for item X. Current count: {}", items_in_stock);
    }

    let result = simulate_db_operation(false);
    if result.is_err() {
        error!("Database operation failed: {:?}", result.err().unwrap());
    }

    // Trace messages are very verbose and usually only enabled for deep debugging.
    trace!("This is a trace message - very detailed.");

    info!("Application shutting down.");
}

fn simulate_db_operation(success: bool) -> Result<(), String> {
    trace!("Entering simulate_db_operation function.");
    if success {
        debug!("Database operation successful.");
        Ok(())
    } else {
        debug!("Database operation failed intentionally.");
        Err("Failed to connect to database".to_string())
    }
}
```

To run this example:
1.  Save the `Cargo.toml` and `main.rs` files in a new Rust project directory (e.g., `my_logging_app`).
2.  Open your terminal in that directory.
3.  Run with default info level (or the default specified in `default_filter_or`): `cargo run` (output will show INFO, WARN, ERROR messages).
4.  Run with debug level: `RUST_LOG=debug cargo run` (output will include DEBUG messages).
5.  Run with trace level: `RUST_LOG=trace cargo run` (output will include TRACE messages).
6.  Run with specific module debug level: `RUST_LOG=rust_logging_example=debug cargo run`
    (Note: `rust_logging_example` should match the `name` field in your `Cargo.toml`)