Struct Queued 

pub struct Queued { /* private fields */ }

An asynchronous, thread-pooled logger with guaranteed completion.

AsyncLogger acts as an orchestration layer that offloads logging side-effects to a background pool of workers. It is designed for high-throughput scenarios where log generation should not block the main application execution.

Architecture: The “Traveling Sender” Pattern

This logger implements a resilient dispatch system using [crossbeam] channels. Each Message is wrapped in a PerishableMessage which carries its own [Sender] clone. This ensures that:

1. Decoupled Retries: Workers can re-queue failed tasks without needing access to the parent logger’s state.
2. Lifespan Tracking: Messages have a finite number of lives, preventing infinite loops in case of persistent service failure.

Graceful Shutdown & Persistence

The AsyncLogger guarantees that no log is lost during program termination:

• Drain Policy: On drop(), the primary sender is destroyed. Workers will continue processing until the internal buffer is empty and all re-queue attempts (lives) are exhausted.
• Thread Synchronization: The logger waits (join) for all worker threads to finish their tasks before allowing the process to exit.

Important Design Considerations

• Ordering: Because this logger uses multiple concurrent workers (MPMC), strict chronological ordering is not guaranteed. While each Message retains its original timestamp, the order in which they reach the final destination may vary due to thread scheduling and retry logic.
• Compatibility: This pattern is ideal for I/O-bound services like local files or standard streams. It is not recommended for services requiring strict sequential consistency (e.g., Loki or Aws).

Example

let service = StandardCoutWrite::new();
let logger = QueuedLogger::new(service, 3, 4); // 3 retries, 4 worker threads
let logger = Logger::new(logger);
logger.log((LogLevel::Info,"System started"));

Implementations

impl Queued

pub fn new( service: Box<dyn Service + Send + Sync>, max_retries: usize, worker_count: usize, ) -> Box<Self>

Creates a new QueuedLogger and initializes the worker pool.

Arguments

• service - The logging service implementation.
• max_retries - How many times a failed log should be re-queued.
• worker_count - The number of background threads to spawn.

pub fn get_service(&self) -> &dyn Service

Returns the base service

pub fn take_service(self) -> Arc<dyn Service + Send + Sync>

Consumes the logger and returns the underlying service.

This method will block the current thread until all background workers have finished processing the current queue and all retries have been exhausted. This ensures that the returned service is in a clean, idle state.

Trait Implementations

impl Drop for Queued

fn drop(&mut self)

Orchestrates a graceful shutdown of the logger.

1. The primary [Sender] is dropped (set to None).
2. This does not immediately close the channel if messages are in the queue, as those messages carry their own [Sender] clones.
3. Once all messages are processed/exhausted, the last [Sender] dies.
4. worker_receiver.recv() returns Err, and threads exit.
5. join() ensures all threads have finished before the program proceeds.

impl LoggerImpl for Queued

fn status(&self) -> LoggerStatus

Checks the health status of the underlying service.

fn log(&self, message: Message)

Dispatches a message to the background worker pool.

Each message is bundled with a clone of the sender to enable self-contained retry logic within the worker threads.

fn as_any(&self) -> &dyn Any

Downcasts the logger to Any for reflection-like capabilities.