codesnips
rust 9 lines · 1 tab

log crate facade for pluggable logging backends

Marcus Chen Jan 2026
1 tab 
use log::{info, warn, error};

fn main() {
    env_logger::init();

    info!("Application started");
    warn!("This is a warning");
    error!("An error occurred");
}
1 file · rust Explain with highlit

The log crate provides logging macros (error!, warn!, info!, debug!, trace!) that are backend-agnostic. Libraries use log, and applications choose the backend (env_logger, simple_logger, or tracing). This decouples logging from the implementation. I use log in libraries and env_logger in binaries for quick setup. The RUST_LOG environment variable controls verbosity: RUST_LOG=debug cargo run. For structured logging, I prefer tracing, but log is simpler and ubiquitous. The facade pattern means changing the logging backend doesn't break libraries, which is why log is the de facto standard in the Rust ecosystem.

Related snips

rust 
struct Config<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_config(line: &str) -> Config {

Lifetime annotations for flexible borrowing in structs

rust lifetimes borrowing
by Marcus Chen 1 tab
rust 
use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free
by Marcus Chen 1 tab
rust 
use tracing::{info, instrument};

#[instrument]
fn process_request(user_id: u64) {
    info!(user_id, "Processing request");
    // Work happens here

tracing for structured logging and distributed tracing

rust observability tracing
by Marcus Chen 1 tab
rust 
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

Channels (mpsc) for message passing between threads

rust concurrency channels
by Marcus Chen 1 tab
rust 
use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    #[arg(short, long)]

clap for CLI argument parsing with derive macros

rust cli clap
by Marcus Chen 1 tab
rust 
macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Called {}", stringify!($func_name));
        }
    };

Declarative macros (macro_rules!) for code generation

rust macros metaprogramming
by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

log crate facade for pluggable logging backends — share card
Link copied