Struct LocalQueueConfig 

pub struct LocalQueueConfig {
    pub size: usize,
    pub ttl: Duration,
    pub refetch_delay: Option<RefetchDelayConfig>,
    pub queue_count: usize,
}

Fields

size: usize

Maximum number of jobs each local queue may fetch and hold at once.

When queue_count is greater than 1, this value is per local queue. For example, size = 1_250 and queue_count = 4 allows up to 5,000 jobs to be locked locally across the worker.

ttl: Duration

How long locally fetched jobs may stay unclaimed before being returned to the database.

refetch_delay: Option<RefetchDelayConfig>

Optional delay strategy used when a fetch returns fewer jobs than requested.

queue_count: usize

Number of independent local queues to run inside this worker.

Multiple queues can improve throughput for very small high-volume jobs by letting the worker fetch several batches in parallel. This also increases the maximum number of jobs locked locally to size * queue_count, so keep size lower when increasing this value.

If this is greater than the worker concurrency, only concurrency queues are started because every local queue needs at least one worker draining it.

Throughput depends on the job payload, handler cost, PostgreSQL latency, connection pool size, worker concurrency, and local queue settings. There is no universal best value; benchmark realistic workloads before changing this in production.

Defaults to 1, which preserves the original single-local-queue behavior.

Implementations

impl LocalQueueConfig

pub fn builder() -> LocalQueueConfigBuilder

pub fn with_size(self, size: usize) -> Self

pub fn with_ttl(self, ttl: Duration) -> Self

pub fn with_refetch_delay(self, refetch_delay: RefetchDelayConfig) -> Self

pub fn with_queue_count(self, queue_count: usize) -> Self

Sets how many independent local queues this worker should run.

size is applied to each queue, so total local capacity is size * queue_count. Higher values increase parallel fetch capacity but can also lock more jobs locally and increase database load.

If this is greater than worker concurrency, it is capped at concurrency. There is no single best value for all workloads, so benchmark realistic jobs before relying on a throughput tuning.

Trait Implementations

impl Clone for LocalQueueConfig

fn clone(&self) -> LocalQueueConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LocalQueueConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LocalQueueConfig

fn default() -> Self

Returns the “default value” for a type.