Move formatting to worker thread

[WiSaGaN]

Currently we have no way to generate an owned version of Arguments except writing a compiler plugin since the parsing of the format string is done by compiler.
We need either

1. Implement our own formatting library.
2. Wait for an owned version of Arguments as in Add an owned version of core::fmt::Arguments<'a> that can be sent over threads rust-lang/rfcs#1538.

[WiSaGaN]

Does https://github.com/Lucretiel/lazy_format work?

[WiSaGaN]

This one as well: https://markrbest.github.io/fast-logging-in-rust/

[WiSaGaN]

gpt-5-pro answer on 2025-10-19:

Short answer: Yes, the idea (“do the string formatting on the worker thread”) can work cleanly—but not by relying on std::fmt::Arguments traveling across threads. Today, fmt::Arguments<'a> is a borrowing container and is not owned/'static, so you can’t just capture the log crate’s Record::args() and ship it to another thread. Rust never stabilized an owned counterpart to fmt::Arguments (the old RFC about it never landed), so you need a different shape. ([GitHub]1)

Below is a minimal, understandable path that preserves elegance and lets you defer formatting:

---

Why the “owned fmt::Arguments” approach won’t fly (today)

• log::Record (what your logger gets) contains args: fmt::Arguments<'_>. That type is borrowing, not owned, and is created by format_args! at the callsite. You cannot safely store or send it to another thread after the macro’s scope ends. ([Docs.rs]2)
• The linked RFC was precisely about adding an owned version of fmt::Arguments; it wasn’t stabilized. So waiting for it isn’t a practical plan. ([GitHub]3)

---

Two simple, robust designs

Option A — Keep using the log macros; format on the caller thread; only I/O is offloaded

This is the simplest code and it stays 100% compatible with log::{info!,…}:

fn log(&self, record: &log::Record<'_>) {
    if !self.enabled(record.metadata()) { return; }

    // Eager formatting in the caller:
    let msg = record.args().to_string();  // <- one allocation
    let meta = Meta {
        level: record.level(),
        target: record.target().to_owned(),
        file: record.file().map(str::to_owned),
        line: record.line(),
        // ... timestamp etc.
    };
    // Send to the worker; worker only does sinks/I/O
    let _ = self.tx.send(Event { meta, msg });
}

• Pros: Almost no new surface area; easiest to reason about; matches how many loggers work (format first, then ship). ([Docs.rs]4)
• Cons: The formatting cost happens on the caller thread.

If your bottleneck is I/O or lock contention, this is usually already good enough. And it keeps your code tiny.

---

Option B — Add tiny “deferred-formatting” macros; ship a formatting closure (recommended if you truly need to move formatting)

To move formatting itself to the worker thread without an owned fmt::Arguments, capture values in a move closure and execute that closure on the worker.

Core idea (about ~25 lines):

// 1) The "thunk" the worker will run to produce text.
type FormatThunk = Box<dyn FnOnce(&mut String) + Send + 'static>;

struct Event {
    level: log::Level,
    target: &'static str,
    file: Option<&'static str>,
    line: Option<u32>,
    thunk: FormatThunk,
}

// 2) Public entry-point used by our macros:
pub fn push_deferred(
    level: log::Level,
    target: &'static str,
    file: Option<&'static str>,
    line: Option<u32>,
    thunk: FormatThunk,
) {
    WORKER_TX.send(Event { level, target, file, line, thunk }).ok();
}

// 3) Minimal macros (names don’t clash with `log` macros):
#[macro_export]
macro_rules! flog {
    ($lvl:expr, $($arg:tt)*) => {{
        $crate::push_deferred(
            $lvl, module_path!(), Some(file!()), Some(line!()),
            Box::new(move |buf: &mut String| {
                use core::fmt::Write as _;
                let _ = buf.write_fmt(format_args!($($arg)*));
            }),
        );
    }};
}

#[macro_export] macro_rules! finfo  { ($($arg:tt)*) => { $crate::flog!(::log::Level::Info,  $($arg)*) } }
#[macro_export] macro_rules! fdebug { ($($arg:tt)*) => { $crate::flog!(::log::Level::Debug, $($arg)*) } }
// … likewise for error, warn, trace

Worker loop:

fn worker(mut sink: impl std::io::Write + Send + 'static) {
    while let Ok(mut ev) = WORKER_RX.recv() {
        let mut msg = String::new();
        (ev.thunk)(&mut msg);                // <-- formatting happens here
        // now write to sinks
        let _ = writeln!(sink, "[{:?}] {}: {}", ev.level, ev.target, msg);
    }
}

What makes this safe? The closure captures whatever values it needs by move and is Send + 'static. There’s no borrowed fmt::Arguments escaping its scope, so there’s no lifetime problem and no need for an “owned arguments” type. This pattern is widely used in async/structured logging ecosystems to defer work. ([Docs.rs]2)

Gotcha to document (and it’s a good thing): the closure must be Send + 'static. If a user writes finfo!("id={}", &some_local_str), the compiler will complain (correctly) that they tried to capture a non-'static borrow. They can fix it with some_local_str.to_owned() when they need to—explicit and clear. (Or keep using the regular log macros for that site.)

---

How to fit this into fastlog with minimal change

1. Keep your existing log::Log impl.

   • If users call the standard log::info! macros, default to Option A (format immediately with record.args().to_string() and offload only I/O). This preserves existing behavior and requires almost no change. log::Record is explicitly designed for this flow. ([Docs.rs]2)

2. Expose the tiny “deferred-formatting” API and macros (finfo!, fdebug!, …) behind a feature flag, e.g. defer-formatting.

   • Users who care about squeezing the last drops of CPU on hot paths can opt in by swapping info! → finfo! (a search‑replace).
   • The macros are tiny and obvious; they keep your codebase elegant.

3. Worker thread stays simple. It just:

   • runs the thunk into a String,
   • stamps metadata (level, target, file/line, timestamp),
   • writes to sinks (stdout/file). You can still use a formatter helper if you like. ([Docs.rs]4)

4. Document the rule of thumb:

   • No change: use regular log macros → formatting on caller (Option A).
   • Strict deferral: use f* macros → formatting on worker (Option B), with 'static captures.

That’s all you need. No new dependencies, no clever unsafe, just ~40 lines.

---

FAQ / Trade‑offs

• “Could we somehow pass fmt::Arguments itself?”
  Not portably/safely across threads. fmt::Arguments is a borrowing container, and the owned version proposed years ago wasn’t stabilized. This is why “format now” or “send a closure” are the two practical choices today. ([Rust Documentation]5)

• “Is Option A fast enough?”
  Very often yes. If output and synchronization dominate, doing formatting on the caller thread is fine and keeps the code minimal. Libraries like env_logger format before writing as well. ([Docs.rs]4)

• “What about structured logging (tracing, slog)?”
  They solve this by transporting typed fields (owned/'static) and formatting in a subscriber/handler. It’s great, but heavier than your “keep it elegant and minimal” goal.

---

What I checked

• The issue exists and is titled “Move formatting to worker thread”, opened Apr 15, 2016. The issue body itself references “Add an owned version of core::fmt::Arguments”—exactly the stabilization that never landed. ([GitHub]6)
• fmt::Arguments is documented as a borrowing container (no owned variant), which is the crux here. ([Rust Documentation]5)
• log::Record is the façade type you receive, created by the macros, with args() returning &fmt::Arguments. That API shape is what forces either format‑now or closure. ([Docs.rs]2)

---

Recommendation

• Ship Option A as the default path (keep code tiny and obvious).
• Offer Option B via tiny macros for users who really want to defer formatting. That keeps the library elegant and the code understandable, while still enabling the approach you asked about.

If you want, I can sketch a minimal PR diff (about one module + a couple of macros) that drops straight into your repo’s current LogBuilder/worker setup.