fern

Fern is a lightweight logging backend for Rust’s log facade that lets you configure formatting, level filters, and output destinations through a single fluent Dispatch builder. Instead of wiring up multiple log::Log implementors by hand, you nest Dispatch instances into a tree, each branch with its own filters and format closure, fanning a single log call out to stdout, files, channels, or other backends.

Optional Cargo features extend the core without adding weight to the default build: ANSI terminal colors via colored, syslog output across four parallel syslog crate versions, signal-triggered log file reopening, and Chrono-based date-rotated file logging. The crate targets predictable, low-overhead logging for CLI tools, daemons, and libraries that just need to plug into log’s macros with minimal setup.

What You Get

• A fluent Dispatch builder for chaining format, level, and level_for filters onto one or more output sinks
• Built-in sinks for stdout, stderr, files, and mpsc channels, plus the ability to nest Dispatch inside Dispatch
• A zero-allocation format callback (FormatCallback/fmt::Arguments) so custom formatting avoids intermediate string allocation
• Optional ANSI color support for log levels via the colored feature and colors module
• Optional Unix syslog output across syslog crate versions 3, 4, 6, and 7 (feature-gated per version)
• Optional date-based file rotation and signal-triggered log file reopening for long-running daemons

Common Use Cases

• Setting up leveled, multi-destination logging in a CLI tool with a few lines in main
• Sending warnings and errors to stderr while routing full trace-level logs to a rotating file
• Adding colorized level output to a terminal application via the colored feature
• Forwarding logs to the Unix syslog daemon from a long-running service
• Silencing noisy dependency logs with level_for overrides while keeping your own crate verbose

Under The Hood

Architecture Fern’s design centers on a builder pattern (the Dispatch struct in builders.rs) that gets converted at .apply()/.into_log() time into an internal representation in log_impl.rs implementing the log::Log trait. Configuration happens through a fluent API (.format(), .level(), .level_for(), .chain()) that recursively nests Dispatch instances — a Dispatch can chain to stdout, stderr, a file, an mpsc sender, or another Dispatch, forming a tree that fans a single log record out to multiple sinks and formats. The Output enum abstracts over these sink types, and log_impl.rs walks the tree at log time, applying per-branch filters and a zero-allocation FormatCallback paired with fmt::Arguments so formatting never requires an intermediate string allocation. Optional backends (colors, syslog, reopenable files, date-based rotation) are compiled in behind Cargo features and wired into the same Dispatch/Output abstractions, so a change to the core chaining model has to be threaded through every optional module.

Tech Stack Fern is a pure-Rust crate (edition 2021, minimum supported Rust version 1.60) with a minimal mandatory dependency footprint — only the log facade crate is required by default. Everything else is optional and feature-gated: colored for ANSI terminal coloring, chrono for the date-based file-rotation backend, four parallel major versions of the syslog crate aliased to coexist, and two versions of reopen plus libc for signal-triggered log-file reopening. There is no async runtime dependency and no build script; the crate builds as a plain library, and CI exercises stable, beta, and a pinned older toolchain across Linux and Windows, testing every feature combination individually and all together.

Code Quality Fern has real integration test coverage: nine test files under tests/, each exercising a distinct sink or backend (global logging, channel logging, file logging, reopening, panic handling, meta-logging deadlock mitigation, deep filter checks), run under every feature combination in CI. Documentation doubles as tests — the crate is full of runnable doctest examples, and cargo doc --all-features runs with warnings treated as errors. Error handling is explicit and typed: errors.rs defines an InitError enum wrapping io::Error and log::SetLoggerError with From conversions rather than swallowing failures. The crate root denies missing_docs, forcing every public item to carry documentation, and naming reads as a fluent sentence across the builder API.

API Design Fern’s signature design choice is the recursively nestable Dispatch builder: because .chain() accepts either a concrete sink or another Dispatch, developers build a tree of independently filtered and formatted loggers in one expression, and the docs explicitly note method order doesn’t matter. Getting started requires almost no boilerplate — a working setup is one chained statement, and it integrates directly with the standard log macros so no fern-specific calls are needed elsewhere in a codebase. The callback-style .format() closure is a deliberate, slightly unusual choice made specifically to avoid a per-log-line allocation, a documented tradeoff of API novelty for hot-path performance. It’s a mature, narrow-purpose logging backend rather than a novel architecture — its ergonomics are the differentiator, not new functionality.