Struct Fmt 

pub struct Fmt<W, F>
where
    W: Write + Send + Sync,
    F: MessageFormatter,
{ /* private fields */ }

A thread-safe logging Service for string-based output destinations.

Fmt service implements the Service trait for types that satisfy std::fmt::Write. It is ideal for in-memory logging, testing, or targets that do not use byte-oriented I/O.

Thread Safety

The internal FmtWriteData is wrapped in a Mutex. This allows the Service to be shared across threads (Send + Sync), while ensuring that only one thread can perform a work operation at a time.

Implementations

impl<W, F> Fmt<W, F>

where W: Write + Send + Sync, F: MessageFormatter + Default,

pub fn new(writer: W) -> Box<Self>

Creates a new, heap-allocated Fmt service.

Parameters

• writer: An object implementing std::fmt::Write.
• formatter: An object implementing MessageFormatter.

Example

let service = FmtWrite::<String, StandardMessageFormatter>::new(String::new());
let logger = QueuedLogger::new(service, 3, 4); // 3 retries, 4 worker threads
let logger = Logger::new(logger);

pub fn with_formatter(writer: W, formatter: F) -> Box<Self>

Creates a new, heap-allocated Fmt service with a custom formatter.

Parameters

• writer: An object implementing std::fmt::Write.
• formatter: An object implementing MessageFormatter.

Example

let service = FmtWrite::<String, StandardMessageFormatter>::new(String::new());
let logger = QueuedLogger::new(service, 3, 4); // 3 retries, 4 worker threads
let logger = Logger::new(logger);

pub fn inspect_writer<R>(&self, f: impl FnOnce(&W) -> R) -> Option<R>

Allows safe, read-only access to the internal buffer without stopping the logger.

Use this to “peek” at logs while the application is still running—perfect for health-check endpoints that expose recent logs or for verifying state in tests.

Thread Safety

This method acquires a mutex lock. While the closure f is executing, any incoming logs from other threads will block until the closure returns. Keep the logic inside the closure as fast as possible.

Returns

• Some(R): The result of your closure if the lock was acquired.
• None: If the internal lock was poisoned by a previous panic.

pub fn recover_writer(self) -> Result<W, ServiceError>

Destroys the Service and reclaims ownership of the underlying buffer or writer.

Use this at the end of a program, a test case, or a lifecycle stage to extract all recorded logs and free up the resources used by the Service.

Ownership & Lifecycle

This method consumes self, meaning the Fmt service can no longer be used after this call. This is the only way to get full, non-cloned ownership of the internal writer (e.g., a String or Vec<u8>).

Guarantees

Because this takes ownership of the Service, it is compile-time guaranteed that no other threads can be writing to the buffer when this is called.

pub fn clear_writer(&self)

where W: Default,

Clears the underlying writer if the type supports it (e.g., String). Useful for reusing the Service in benchmarks or test suites.

Trait Implementations

impl<W, F> Fallback for Fmt<W, F>

where W: Write + Send + Sync + 'static, F: MessageFormatter + 'static,

fn fallback(&self, error: &ServiceError, msg: &Message)

Attempts to log an error to stdout if the primary work call fails.

This method performs a best-effort write. If the mutex is locked by a hanging thread, the fallback will be skipped to avoid a deadlock.

impl<W, F> Service for Fmt<W, F>

where W: Write + Send + Sync + 'static, F: MessageFormatter + 'static,

fn status(&self) -> LoggerStatus

Returns the current operational status. Currently always returns LoggerStatus::Running.

fn work(&self, msg: &Message) -> Result<(), ServiceError>

Acquires a lock and writes a formatted Message to the internal writer.

This method uses MessageFormatter::format_fmt to perform the write.

Errors

• Returns ServiceError::LockPoisoned if the internal mutex is poisoned.
• Forwards any ServiceError returned by the formatter.

fn as_any(&self) -> &dyn Any

Returns a reference to the underlying type as Any for downcasting.