RustQueue

https://docs.rs/rustqueue/0.2.0/rustqueue/
Admin
RustQueue is a high-performance job queue system written in Rust that provides REST API endpoints...
Tokens:92,806
Snippets:1,186
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Default Prometheus Recorder

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Installs the default Prometheus recorder if no global recorder is already set. Returns a Result indicating success or failure.

```rust
pub fn install_default_prometheus_if_unset() -> Result<Self>
```

--------------------------------

### install_default_prometheus_if_unset

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Install the default Prometheus recorder unless a global recorder already exists.

```APIDOC
## install_default_prometheus_if_unset

### Description
Install the default Prometheus recorder unless a global recorder already exists.

### Method
`pub fn install_default_prometheus_if_unset() -> Result<Self>`
```

--------------------------------

### Start TCP Server Function Signature

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/protocol/fn.start_tcp_server.html

This is the function signature for starting a TCP server. It takes a TcpListener, a QueueManager, authentication configuration, and a shutdown signal receiver.

```rust
pub async fn start_tcp_server(
    listener: TcpListener,
    manager: Arc<QueueManager>,
    auth_config: AuthConfig,
    shutdown_rx: Receiver<bool>,
)
```

--------------------------------

### RqState Usage Example

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/axum_integration/struct.RqState.html

Demonstrates how to use RqState as a handler parameter to interact with RustQueue methods.

```APIDOC
## RqState

Axum extractor that provides access to the `RustQueue` instance.
Expects `Arc<RustQueue>` as the router state. Use it as a handler parameter and call any `RustQueue` method directly:

```rust
async fn handler(rq: RqState) -> impl IntoResponse {
    rq.push("queue", "job", json!({}), None).await.unwrap();
}
```
```

--------------------------------

### install_external_prometheus_recorder

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Install an externally created Prometheus recorder and keep its handle.

```APIDOC
## install_external_prometheus_recorder

### Description
Install an externally created Prometheus recorder and keep its handle.

### Method
`pub fn install_external_prometheus_recorder(recorder: PrometheusRecorder) -> Result<Self>`
```

--------------------------------

### Create a New QueueRateLimiter

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/rate_limit/struct.QueueRateLimiter.html

Initializes a new QueueRateLimiter instance with no queues pre-configured. Use this to start managing rate limits.

```rust
pub fn new() -> Self
```

--------------------------------

### Install External Prometheus Recorder

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Installs an externally created Prometheus recorder and retains a handle to it. This allows for direct management of the Prometheus recorder.

```rust
pub fn install_external_prometheus_recorder( recorder: PrometheusRecorder, ) -> Result<Self>
```

--------------------------------

### start_scheduler

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/scheduler/index.html

Starts the background scheduler that periodically runs housekeeping tasks.

```APIDOC
## start_scheduler

### Description
Start the background scheduler that periodically runs housekeeping tasks.

### Function Signature
`fn start_scheduler()`
```

--------------------------------

### Axum Quick Start with RustQueue

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/axum_integration/index.html

Demonstrates setting up an Axum application with RustQueue, defining a handler that uses RqState to enqueue items, and configuring the router with application state.

```rust
use axum::{Router, Json, routing::post};
use rustqueue::RustQueue;
use rustqueue::axum_integration::RqState;
use serde_json::json;
use std::sync::Arc;

async fn enqueue(rq: RqState) -> Json<serde_json::Value> {
    let id = rq.push("emails", "send-welcome", json!({}), None).await.unwrap();
    Json(json!({"id": id.to_string()}))
}

let rq = RustQueue::memory().build().unwrap();
let app = Router::new()
    .route("/enqueue", post(enqueue))
    .with_state(Arc::new(rq));
```

--------------------------------

### Install External Recorder

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Installs an externally provided recorder that implements the Recorder trait. This is useful when integrating with a larger platform's metrics system. The recorder must be Send, Sync, and 'static.

```rust
pub fn install_external_recorder<R>(recorder: R) -> Result<Self>
where R: Recorder + Send + Sync + 'static,
```

--------------------------------

### start_tcp_server

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/protocol/fn.start_tcp_server.html

Starts accepting TCP connections on a given listener. Each connection is handled in a separate tokio task. The server runs until a shutdown signal is received. Authentication is handled via the auth_config.

```APIDOC
## start_tcp_server

### Description
Start accepting TCP connections on the given listener. Each connection is handled in its own tokio task via `handler::handle_connection`. This function runs until the `shutdown_rx` watch channel signals shutdown, at which point it stops accepting new connections. In-flight connections continue until they finish their current command. The `auth_config` is shared with every connection handler. When auth is enabled, clients must send an `auth` command before any other command is accepted.

### Signature
```rust
pub async fn start_tcp_server(
    listener: TcpListener,
    manager: Arc<QueueManager>,
    auth_config: AuthConfig,
    shutdown_rx: Receiver<bool>,
)
```
```

--------------------------------

### Get Prometheus Handle

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Retrieves an Option containing a PrometheusHandle, which is used by the `/api/v1/metrics/prometheus` endpoint to render metrics. Returns None if no Prometheus recorder is installed.

```rust
pub fn prometheus_handle(&self) -> Option<PrometheusHandle>
```

--------------------------------

### install_external_recorder

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/metrics_registry/struct.MetricsRegistry.html

Install an externally provided recorder as the global metrics recorder. This is useful when RustQueue runs inside a larger platform with a shared metrics registry.

```APIDOC
## install_external_recorder

### Description
Install an externally provided recorder as the global metrics recorder. This is useful when RustQueue runs inside a larger platform with a shared metrics registry.

### Method
`pub fn install_external_recorder<R>(recorder: R) -> Result<Self>`

### Type Parameters
* `R`: Must implement `Recorder + Send + Sync + 'static`.
```

--------------------------------

### start_webhook_dispatcher

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/fn.start_webhook_dispatcher.html

Starts the webhook event dispatcher background task. This function subscribes to the broadcast channel and dispatches events to the appropriate webhooks.

```APIDOC
## Function start_webhook_dispatcher

### Description
Start the webhook event dispatcher background task. Subscribes to the broadcast channel and dispatches events to matching webhooks.

### Signature
```rust
pub fn start_webhook_dispatcher(
    manager: Arc<WebhookManager>,
    event_rx: Receiver<JobEvent>,
) -> JoinHandle<()>
```

### Parameters
* `manager` (Arc<WebhookManager>) - A shared reference to the WebhookManager.
* `event_rx` (Receiver<JobEvent>) - A channel receiver for JobEvent.

### Returns
* `JoinHandle<()>` - A handle to the spawned background task.
```

--------------------------------

### Get Ready Scheduled Jobs

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Retrieves all jobs that are scheduled to be ready at the current time. Takes a DateTime<Utc> representing the current time and returns a vector of jobs.

```rust
fn get_ready_scheduled<'life0, 'async_trait>(
  &'life0 self,
  now: DateTime<Utc>,
) -> Pin<Box<dyn Future<Output = Result<Vec<Job>>> + Send + 'async_trait>>
where
  Self: 'async_trait,
  'life0: 'async_trait,
```

--------------------------------

### start_scheduler

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/scheduler/fn.start_scheduler.html

Starts the background scheduler that periodically runs housekeeping tasks. This spawns a tokio task that runs on a configurable interval to promote delayed jobs, execute due schedules, check for timed-out jobs, detect stalled jobs, update queue depth metrics, and run retention cleanup. Returns a JoinHandle that can be used to abort the scheduler.

```APIDOC
## Function start_scheduler

### Description
Starts the background scheduler that periodically runs housekeeping tasks. This spawns a tokio task that runs on a configurable interval:
  * Promote delayed jobs whose delay has expired
  * Execute due schedules (cron + interval)
  * Check for timed-out jobs
  * Detect stalled jobs (no heartbeat within `stall_timeout_ms`)
  * Update queue depth gauge metrics
  * Run retention cleanup every 60 ticks (~1 minute at 1s tick)

### Signature
```rust
pub fn start_scheduler(
    manager: Arc<QueueManager>,
    tick_interval_ms: u64,
    stall_timeout_ms: u64,
    retention: RetentionConfig,
) -> JoinHandle<()>
```

### Returns
A `JoinHandle` that can be used to abort the scheduler.
```

--------------------------------

### HybridStorage::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Creates a new HybridStorage instance. It wraps a durable backend and starts an immediate background snapshot task. The in-memory state is populated from disk upon the first operation.

```APIDOC
## HybridStorage::new

### Description
Creates a new hybrid storage wrapping the given durable backend. Starts a background snapshot task immediately. The in-memory state is populated from disk on the first operation.

### Signature
```rust
pub fn new(inner: Arc<dyn StorageBackend>, config: HybridConfig) -> Self
```
```

--------------------------------

### Serve Dashboard Static Assets

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/dashboard/fn.dashboard_routes.html

Handles GET requests for arbitrary paths within the dashboard, serving static assets.

```APIDOC
## GET /dashboard/{*path}

### Description
Serves arbitrary static assets from the dashboard, allowing for routing of SPA assets.

### Method
GET

### Endpoint
/dashboard/{*path}
```

--------------------------------

### Serve Dashboard Index

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/dashboard/fn.dashboard_routes.html

Handles GET requests to the root dashboard path, serving the index.html file.

```APIDOC
## GET /dashboard

### Description
Serves the main `index.html` file for the authenticated dashboard.

### Method
GET

### Endpoint
/dashboard
```

--------------------------------

### Create New HybridStorage Instance

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Creates a new HybridStorage instance. It wraps a given durable backend and configuration, and starts a background snapshot task immediately. The in-memory state is populated from disk on the first operation.

```rust
pub fn new(inner: Arc<dyn StorageBackend>, config: HybridConfig) -> Self>
```

--------------------------------

### Start the Background Scheduler

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/scheduler/fn.start_scheduler.html

Initiates a background scheduler task that handles periodic housekeeping operations. This function is used to manage delayed jobs, execute schedules, check for timeouts, detect stalled jobs, update metrics, and run retention cleanup. It returns a JoinHandle for controlling the scheduler task.

```rust
pub fn start_scheduler(
    manager: Arc<QueueManager>,
    tick_interval_ms: u64,
    stall_timeout_ms: u64,
    retention: RetentionConfig,
) -> JoinHandle<()>
```

--------------------------------

### RedbStorage::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/redb/struct.RedbStorage.html

Creates or opens a redb database at the specified path. If the database does not exist, it will be created, and the required tables will be set up automatically.

```APIDOC
## RedbStorage::new

### Description
Creates or opens a redb database at the given path. On first open the required tables are created automatically.

### Signature
```rust
pub fn new(path: impl AsRef<Path>) -> Result<Self>
```

### Parameters
* `path` (impl AsRef<Path>): The path to the redb database file.
```

--------------------------------

### Initialize Router

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/queues/fn.routes.html

The `routes` function is responsible for setting up the main application router, which defines all available API endpoints and their associated handlers. It returns a `Router` instance configured with the application's state.

```APIDOC
## routes

### Description
Initializes and returns the main application router.

### Function Signature
```rust
pub fn routes() -> Router<Arc<AppState>>
```

### Returns
A `Router` instance configured with the application's shared state (`Arc<AppState>`). This router defines the structure of the API endpoints.
```

--------------------------------

### Initialize and Use RustQueue

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/index.html

Demonstrates initializing RustQueue with an embedded Redb database, pushing a job, pulling jobs, and acknowledging them. Jobs persist across restarts.

```rust
use rustqueue::RustQueue;
use serde_json::json;

let rq = RustQueue::redb("./jobs.db")?.build()?;
let id = rq.push("emails", "send-welcome", json!({"to": "a@b.com"}), None).await?;
let jobs = rq.pull("emails", 1).await?;
rq.ack(jobs[0].id, None).await?;
```

--------------------------------

### Initialize API Routes

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/jobs/fn.routes.html

The `routes` function is responsible for setting up the main application router, defining all available API endpoints and their associated handlers. It returns a `Router` instance configured with the application's state.

```APIDOC
## Function routes

rustqueue::api::jobs

### Summary

```rust
pub fn routes() -> Router<Arc<AppState>>
```

### Description

This function initializes and returns the main application router. It configures the endpoints and associates them with the application's shared state (`Arc<AppState>`). This is the entry point for defining the API's structure and available operations.
```

--------------------------------

### Create or Open RedbDatabase

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/redb/struct.RedbStorage.html

Creates or opens a redb database at the specified path. Required tables are automatically created on the first open.

```rust
pub fn new(path: impl AsRef<Path>) -> Result<Self>
```

--------------------------------

### decode_channel_frame

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/protocol/binary/fn.decode_channel_frame.html

Decodes a channel frame, extracting the channel_id and inner command data. The input `data` must start with the 0x10 command byte. Returns `(channel_id, inner_frame)` where `inner_frame` starts with the inner command byte (0x01-0x03).

```APIDOC
## decode_channel_frame

### Description
Decode a channel frame, extracting the channel_id and inner command data.
The input `data` must start with the 0x10 command byte. Returns `(channel_id, inner_frame)` where `inner_frame` starts with the inner command byte (0x01-0x03).

### Signature
```rust
pub fn decode_channel_frame(data: &[u8]) -> Result<(u16, &[u8]), ProtocolError>
```
```

--------------------------------

### get_flow_jobs

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/queue/struct.QueueManager.html

Gets all jobs belonging to a flow.

```APIDOC
## get_flow_jobs

### Description
Get all jobs belonging to a flow.

### Method
`async fn`

### Parameters
#### Path Parameters
- **flow_id** (str) - Required - The ID of the flow.

### Response
- `Result<Vec<Job>, RustQueueError>`: A vector of jobs belonging to the specified flow.
```

--------------------------------

### get_queue_stats

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/axum_integration/struct.RqState.html

Get counts for a specific queue.

```APIDOC
## get_queue_stats

Get counts for a specific queue.

### Method

`async fn get_queue_stats(&self, queue: &str) -> Result<QueueCounts, RustQueueError>`
```

--------------------------------

### routes()

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/openapi/fn.routes.html

Builds and returns a router that serves the OpenAPI JSON specification and the Scalar UI for interacting with the API.

```APIDOC
## Function routes()

### Description
Build a router that serves the OpenAPI JSON spec and Scalar UI.

### Signature
```rust
pub fn routes() -> Router<Arc<AppState>>
```
```

--------------------------------

### Pointable Implementation - Dereferencing

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/auth/enum.TokenValidationError.html

Dereferences a raw pointer to get an immutable or mutable reference to the value.

```rust
unsafe fn deref<'a>(ptr: usize) -> &'a T
```

```rust
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
```

--------------------------------

### routes()

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/health/fn.routes.html

This function initializes and returns the main application router, including all health check routes.

```APIDOC
## routes()

### Description
Initializes and returns the main application router, which includes all health check routes.

### Signature
```rust
pub fn routes() -> Router<Arc<AppState>>
```

### Returns
A `Router` instance configured with the application's state and routes.
```

--------------------------------

### Generic TypeId Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/jobs/struct.DlqResponse.html

Provides a way to get the TypeId of any type that implements the 'static trait.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Initialize BufferedRedbStorage

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbStorage.html

Constructs a new BufferedRedbStorage instance. Wrap an existing storage backend with write coalescing capabilities.

```rust
pub fn new(inner: Arc<dyn StorageBackend>, config: BufferedRedbConfig) -> Self>
```

--------------------------------

### WebhookManager::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/struct.WebhookManager.html

Creates a new instance of the WebhookManager with the provided configuration.

```APIDOC
## WebhookManager::new

### Description
Create a new webhook manager.

### Signature
```rust
pub fn new(config: WebhookConfig) -> Self
```
```

--------------------------------

### Get Active Schedules with BufferedRedbStorage

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbStorage.html

Retrieves all active schedules from the storage. This method is part of the StorageBackend trait.

```rust
fn get_active_schedules<'life0, 'async_trait>(
    &'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Vec<Schedule>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

--------------------------------

### Get Schema Name for ListQueuesResponse

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/queues/struct.ListQueuesResponse.html

Returns the name of the schema for ListQueuesResponse, used in OpenAPI documentation generation.

```rust
fn name() -> Cow<'static, str>
```

--------------------------------

### routes

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/websocket/fn.routes.html

Sets up and returns the websocket router for the Rustqueue API, configured with the application's state.

```APIDOC
## Function routes

Rustqueue API Websocket

### Summary
```rust
pub fn routes() -> Router<Arc<AppState>>
```

### Description
This function initializes and returns a `Router` instance from the `axum` crate. The router is specifically configured to handle websocket connections and is typed with `Arc<AppState>`, indicating that it shares application state across all websocket connections. This is a fundamental part of setting up the websocket server for the Rustqueue application.
```

--------------------------------

### Policy Combination: Or

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/struct.Webhook.html

Creates a new Policy that returns Action::Follow if either the current policy or the other policy returns Action::Follow.

```APIDOC
## fn or<P, B, E>(self, other: P) -> Or<T, P>

### Description
Create a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### Parameters
- `other`: P - The other policy to combine with.

### Returns
- `Or<T, P>`: A new policy representing the logical OR of the two policies.
```

--------------------------------

### Get Queue Counts

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Retrieves the counts of jobs in various states for a specified queue. Returns a QueueCounts struct.

```rust
fn get_queue_counts<'life0, 'life1, 'async_trait>(
  &'life0 self,
  queue: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<QueueCounts>> + Send + 'async_trait>>
where
  Self: 'async_trait,
  'life0: 'async_trait,
  'life1: 'async_trait,
```

--------------------------------

### Get a Webhook by ID

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/struct.WebhookManager.html

Retrieves a specific webhook by its unique identifier (UUID). Returns None if the webhook is not found.

```rust
pub fn get(&self, id: Uuid) -> Option<Webhook>
```

--------------------------------

### Get Job by ID

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/redb/struct.RedbStorage.html

Retrieves a job from the storage backend using its unique JobId. Returns None if the job is not found.

```rust
fn get_job<'life0, 'async_trait>(
    &'life0 self,
    id: JobId,
) -> Pin<Box<dyn Future<Output = Result<Option<Job>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

--------------------------------

### Create or Open RedbDatabase with Durability

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/redb/struct.RedbStorage.html

Creates or opens a redb database with explicit write durability settings.

```rust
pub fn new_with_durability(
    path: impl AsRef<Path>,
    durability: RedbDurability,
) -> Result<Self>
```

--------------------------------

### QueueRateLimiter::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/rate_limit/struct.QueueRateLimiter.html

Creates a new QueueRateLimiter instance with no queues initially configured.

```APIDOC
## QueueRateLimiter::new

### Description
Create a new rate limiter with no queues configured.

### Method
```rust
pub fn new() -> Self
```

### Returns
A new `QueueRateLimiter` instance.
```

--------------------------------

### Get Job by ID from HybridStorage

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Retrieves a job from the HybridStorage by its JobId. Returns an Option<Job> which is None if the job is not found.

```rust
fn get_job<'life0, 'async_trait>(
  &'life0 self,
  id: JobId,
) -> Pin<Box<dyn Future<Output = Result<Option<Job>>> + Send + 'async_trait>>
where
  Self: 'async_trait,
  'life0: 'async_trait,
```

--------------------------------

### Combine Policies with AND

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/queues/struct.ListQueuesResponse.html

Creates a new policy that requires both the current and the other policy to return Action::Follow.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

--------------------------------

### Combine Policies with OR

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/queues/struct.ListQueuesResponse.html

Creates a new policy that allows Action::Follow if either the current or the other policy returns Action::Follow.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

--------------------------------

### Use RqState in Axum handler

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/axum_integration/struct.RqState.html

Example of using RqState as a handler parameter to access RustQueue methods like push.

```rust
async fn handler(rq: RqState) -> impl IntoResponse {
    rq.push("queue", "job", json!({}), None).await.unwrap();
}

```

--------------------------------

### Create a new WebhookManager

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/struct.WebhookManager.html

Instantiates a new WebhookManager with the provided configuration.

```rust
pub fn new(config: WebhookConfig) -> Self
```

--------------------------------

### Get Ready Scheduled Jobs with BufferedRedbStorage

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbStorage.html

Retrieves jobs that are scheduled to be ready at the current time. This method is part of the StorageBackend trait.

```rust
fn get_ready_scheduled<'life0, 'async_trait>(
    &'life0 self,
    now: DateTime<Utc>,
) -> Pin<Box<dyn Future<Output = Result<Vec<Job>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
```

--------------------------------

### QueueManager::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/queue/struct.QueueManager.html

Creates a new QueueManager instance, requiring a storage backend implementation.

```APIDOC
## QueueManager::new

### Description
Create a new `QueueManager` backed by the given storage implementation.

### Signature
`pub fn new(storage: Arc<dyn StorageBackend>) -> Self`

### Parameters
* `storage` (Arc<dyn StorageBackend>) - The storage backend implementation to use.
```

--------------------------------

### Get Error Source

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/error/enum.RustQueueError.html

Retrieves the lower-level source error if the RustQueueError was caused by another error. Useful for debugging nested errors.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

--------------------------------

### Get HTTP Status Code

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/error/enum.RustQueueError.html

Returns the appropriate HTTP status code for the error. Use this to set the status in API responses.

```rust
pub fn http_status(&self) -> u16
```

--------------------------------

### Get Machine-Readable Error Code

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/error/enum.RustQueueError.html

Retrieves a machine-readable error code string for API responses. This is useful for programmatic error handling.

```rust
pub fn error_code(&self) -> &'static str
```

--------------------------------

### routes

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/prometheus/fn.routes.html

Sets up the API routes for Prometheus metrics.

```APIDOC
## routes

### Description
Sets up the API routes for Prometheus metrics.

### Signature
```rust
pub fn routes() -> Router<Arc<AppState>>
```
```

--------------------------------

### Get Statistics for a Specific Queue

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueue.html

Retrieves the current job counts for a specific queue. This is useful for monitoring individual queue loads.

```rust
pub async fn get_queue_stats( &self, queue: &str, ) -> Result<QueueCounts, RustQueueError>
```

--------------------------------

### CloneToUninit Implementation (Nightly)

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/auth/enum.TokenValidationError.html

Nightly-only experimental API for performing copy-assignment from self to an uninitialized destination.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Policy::or

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/models/struct.QueueCounts.html

Creates a new Policy that returns Action::Follow if either self or other returns Action::Follow.

```APIDOC
## fn or<P, B, E>(self, other: P) -> Or<T, P>

### Description
Create a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### Parameters
* `other`: Another policy to combine with.

### Returns
A new `Or` policy combining `self` and `other`.
```

--------------------------------

### Get Human-Readable Message for TokenValidationError

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/auth/enum.TokenValidationError.html

Provides a human-readable string representation for each TokenValidationError variant, aligned with RustQueue API error responses.

```rust
pub fn message(self) -> &'static str
```

--------------------------------

### Format RustQueueError for Display

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/error/enum.RustQueueError.html

Implements the Display trait for RustQueueError, allowing it to be formatted as a string. This is the standard way to get a user-friendly error message.

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

--------------------------------

### Get Dead Letter Queue Jobs

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Retrieves jobs from the dead-letter queue (DLQ) for a given queue, with an optional limit. Returns a vector of jobs.

```rust
fn get_dlq_jobs<'life0, 'life1, 'async_trait>(
  &'life0 self,
  queue: &'life1 str,
  limit: u32,
) -> Pin<Box<dyn Future<Output = Result<Vec<Job>>> + Send + 'async_trait>>
where
  Self: 'async_trait,
  'life0: 'async_trait,
  'life1: 'async_trait,
```

--------------------------------

### PolicyExt Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbConfig.html

Extends `BufferedRedbConfig` with policy combinators like `and` and `or` for creating complex policy logic.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
```

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
```

--------------------------------

### RustQueueBuilder Methods

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueueBuilder.html

Methods for configuring and building a RustQueue instance.

```APIDOC
## RustQueueBuilder

Builder for constructing a `RustQueue` instance. Obtained via `RustQueue::memory()` or [`RustQueue::redb(path)`]. Call `.build()` to finalise.

### `with_write_coalescing`

Enable write coalescing with the given configuration.
When enabled, single `insert_job` and `complete_job` calls are buffered and flushed as batches for significantly higher throughput.

#### Signature
```rust
pub fn with_write_coalescing(self, config: BufferedRedbConfig) -> Self
```

### `with_hybrid_config`

Configure the hybrid storage snapshot settings.
Only effective when using `RustQueue::hybrid()`.

#### Signature
```rust
pub fn with_hybrid_config(self, config: HybridConfig) -> Self
```

### `with_worker_registry`

Attach a worker plugin registry used for engine-specific dispatch.

#### Signature
```rust
pub fn with_worker_registry(self, registry: Arc<WorkerRegistry>) -> Self
```

### `build`

Build the `RustQueue` instance.

#### Signature
```rust
pub fn build(self) -> Result<RustQueue>
```
```

--------------------------------

### Get Dead Letter Queue Jobs with BufferedRedbStorage

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbStorage.html

Retrieves jobs from the dead letter queue (DLQ) up to a specified limit. This method is part of the StorageBackend trait.

```rust
fn get_dlq_jobs<'life0, 'life1, 'async_trait>(
    &'life0 self,
    queue: &'life1 str,
    limit: u32,
) -> Pin<Box<dyn Future<Output = Result<Vec<Job>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
```

--------------------------------

### Create a new QueueManager

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/queue/struct.QueueManager.html

Initializes a new QueueManager instance. Requires an `Arc` reference to a `StorageBackend` implementation.

```rust
pub fn new(storage: Arc<dyn StorageBackend>) -> Self>
```

--------------------------------

### Get Jobs by Flow ID

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/hybrid/struct.HybridStorage.html

Retrieves all jobs associated with a specific flow ID. This is useful for monitoring the status of DAG flows. Returns a vector of jobs.

```rust
fn get_jobs_by_flow_id<'life0, 'life1, 'async_trait>(
  &'life0 self,
  flow_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Vec<Job>>> + Send + 'async_trait>>
where
  Self: 'async_trait,
  'life0: 'async_trait,
  'life1: 'async_trait,
```

--------------------------------

### Workflow::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/struct.Workflow.html

Creates a new, empty workflow.

```APIDOC
## Workflow::new

### Description
Create an empty workflow.

### Method
```rust
pub fn new() -> Self
```
```

--------------------------------

### Policy Combination: And

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/struct.Webhook.html

Creates a new Policy that requires both the current policy and the other policy to return Action::Follow.

```APIDOC
## fn and<P, B, E>(self, other: P) -> And<T, P>

### Description
Create a new `Policy` that returns `Action::Follow` only if `self` and `other` return `Action::Follow`.

### Parameters
- `other`: P - The other policy to combine with.

### Returns
- `And<T, P>`: A new policy representing the logical AND of the two policies.
```

--------------------------------

### QueueCounts Struct Definition

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/models/struct.QueueCounts.html

Defines the structure for holding counts of jobs in various states within a queue. Use this struct to get a snapshot of the queue's status.

```rust
pub struct QueueCounts {
    pub waiting: u64,
    pub active: u64,
    pub delayed: u64,
    pub completed: u64,
    pub failed: u64,
    pub dlq: u64,
    pub blocked: u64,
}
```

--------------------------------

### Configure Hybrid Storage Snapshot Settings

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueueBuilder.html

Configures the snapshot settings for hybrid storage. This is only effective when using RustQueue::hybrid().

```rust
pub fn with_hybrid_config(self, config: HybridConfig) -> Self
```

--------------------------------

### Decode Channel Frame

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/protocol/binary/fn.decode_channel_frame.html

Use this function to decode a channel frame from binary data. The input must start with the 0x10 command byte. It returns a tuple containing the channel ID and the inner frame data.

```rust
pub fn decode_channel_frame(data: &[u8]) -> Result<(u16, &[u8]), ProtocolError>
```

--------------------------------

### WorkerRegistry::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/plugins/struct.WorkerRegistry.html

Creates a new instance of WorkerRegistry.

```APIDOC
## WorkerRegistry::new

### Description
Creates a new instance of WorkerRegistry.

### Method
`pub fn new() -> Self`
```

--------------------------------

### Workflow::execute

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/struct.Workflow.html

Executes the workflow from the given initial input.

```APIDOC
## Workflow::execute

### Description
Execute the workflow from the given initial input.

### Method
```rust
pub async fn execute(&self, input: Value) -> Result<Value>
```
```

--------------------------------

### Define AppState Struct

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/struct.AppState.html

Defines the structure for shared application state, including a queue manager, start time, metrics handle, event sender, authentication configuration, rate limiter, and an optional webhook manager.

```rust
pub struct AppState {
    pub queue_manager: Arc<QueueManager>,
    pub start_time: Instant,
    pub metrics_handle: Option<PrometheusHandle>,
    pub event_tx: Sender<JobEvent>,
    pub auth_config: AuthConfig,
    pub auth_rate_limiter: AuthRateLimiter,
    pub webhook_manager: Option<Arc<WebhookManager>>,
}
```

--------------------------------

### WorkflowStep::engine Method Signature

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/trait.WorkflowStep.html

The `engine` method returns a string slice identifying the workflow engine responsible for this step. Examples include "pixelforge", "oxid", or "ferrox".

```rust
fn engine(&self) -> &str;
```

--------------------------------

### AuthRateLimiter::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/auth/struct.AuthRateLimiter.html

Creates a new instance of AuthRateLimiter.

```APIDOC
## AuthRateLimiter::new

### Description
Creates a new instance of `AuthRateLimiter`.

### Method
`new()`

### Returns
- `Self`: A new `AuthRateLimiter` instance.
```

--------------------------------

### BufferedRedbStorage::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbStorage.html

Constructs a new BufferedRedbStorage instance, wrapping an existing storage backend with write coalescing capabilities.

```APIDOC
## BufferedRedbStorage::new

### Description
Wrap an existing storage backend with write coalescing.

### Signature
```rust
pub fn new(inner: Arc<dyn StorageBackend>, config: BufferedRedbConfig) -> Self
```

### Parameters
* `inner`: An `Arc` containing a `StorageBackend` to be wrapped.
* `config`: The `BufferedRedbConfig` to configure the buffering behavior.
```

--------------------------------

### RedbStorage::new_with_durability

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/redb/struct.RedbStorage.html

Creates or opens a redb database at the specified path with explicit control over write durability.

```APIDOC
## RedbStorage::new_with_durability

### Description
Creates or opens a redb database at the given path with explicit write durability.

### Signature
```rust
pub fn new_with_durability( path: impl AsRef<Path>, durability: RedbDurability, ) -> Result<Self>
```

### Parameters
* `path` (impl AsRef<Path>): The path to the redb database file.
* `durability` (RedbDurability): The desired write durability setting for the database.
```

--------------------------------

### TryFrom Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.RetentionConfig.html

Allows for fallible conversion from one type to another.

```APIDOC
## impl<T, U> TryFrom<U> for T
where U: Into<T>,

### type Error = Infallible
The type returned in the event of a conversion error.

### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

--------------------------------

### Policy AND combination

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/plugins/struct.WorkerRegistry.html

Creates a new `Policy` that returns `Action::Follow` only if both `self` and `other` policies return `Action::Follow`. Part of `PolicyExt`.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>
```

--------------------------------

### Create Hybrid Memory+Disk RustQueue Builder

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueue.html

Creates a builder for a RustQueue with hybrid storage. Reads/writes use an in-memory DashMap, and dirty entries are periodically snapshotted to a redb file. Up to `snapshot_interval` of data may be lost on crash.

```rust
pub fn hybrid(path: impl AsRef<Path>) -> Result<RustQueueBuilder>
```

--------------------------------

### Default AuthConfig Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.AuthConfig.html

Provides a default configuration for AuthConfig. Use this when no specific configuration is provided.

```rust
fn default() -> AuthConfig
```

--------------------------------

### TryInto Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.RetentionConfig.html

Enables fallible conversion into another type.

```APIDOC
## impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### Job Blanket Implementations

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/models/struct.Job.html

Demonstrates various blanket implementations for the Job struct, including Any, Borrow, BorrowMut, CloneToUninit, From, FromRef, and Instrument.

```rust
fn type_id(&self) -> TypeId
```

```rust
fn borrow(&self) -> &T
```

```rust
fn borrow_mut(&mut self) -> &mut T
```

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

```rust
fn from(t: T) -> T
```

```rust
fn from_ref(input: &T) -> T
```

```rust
fn instrument(self, span: Span) -> Instrumented<Self>
```

--------------------------------

### Clone Implementation for StorageConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.StorageConfig.html

Provides a method to create a deep copy of the StorageConfig.

```rust
fn clone(&self) -> StorageConfig
```

--------------------------------

### Clone Implementation for JobsConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.JobsConfig.html

Allows creating a copy of the JobsConfig. Use this when you need an independent configuration instance.

```rust
fn clone(&self) -> JobsConfig
```

--------------------------------

### TryFrom

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.QueueRateLimitMap.html

Allows for fallible conversion from one type to another.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Allows for fallible conversion from one type to another.

#### type Error = Infallible

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/websocket/struct.JobEvent.html

Explains the `TryFrom` and `TryInto` trait implementations for type conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Enables attempting to convert a value of type `U` into type `T`.

### Associated Types
- `type Error = Infallible`: The type returned in the event of a conversion error.

### Methods
- `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.

## impl<T, U> TryInto<U> for T

### Description
Enables attempting to convert `self` into type `U`.

### Associated Types
- `type Error = <U as TryFrom<T>>::Error`: The type returned in the event of a conversion error.

### Methods
- `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

--------------------------------

### PartialEq Implementation for LoggingConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.LoggingConfig.html

Enables comparison of two LoggingConfig instances for equality.

```rust
fn eq(&self, other: &LoggingConfig) -> bool
```

--------------------------------

### Define API Routes

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/jobs/fn.routes.html

This function initializes and returns a Router for the application, specifying the API routes for job-related operations. It requires an `Arc<AppState>` to manage application state.

```rust
pub fn routes() -> Router<Arc<AppState>>
```

--------------------------------

### TryInto

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.QueueRateLimitMap.html

Enables fallible conversion into another type.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Enables fallible conversion into another type.

#### type Error = <U as TryFrom<T>>::Error

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Pointable

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/models/struct.Job.html

Defines operations for pointer manipulation and initialization.

```APIDOC
## impl<T> Pointable for T

#### const ALIGN: usize

The alignment of pointer.

#### type Init = T

The type for initializers.

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
```

--------------------------------

### Dashboard Routes

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/dashboard/fn.routes.html

Builds the full dashboard router, including the landing page, the Single Page Application (SPA), and static assets.

```APIDOC
## GET /

### Description
Serves the marketing landing page.

### Method
GET

### Endpoint
/

## GET /dashboard

### Description
Serves the main dashboard `index.html` file.

### Method
GET

### Endpoint
/dashboard

## GET /dashboard/{*path}

### Description
Serves arbitrary static assets within the dashboard.

### Method
GET

### Endpoint
/dashboard/{*path}
```

--------------------------------

### Policy OR combination

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/plugins/struct.WorkerRegistry.html

Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` policies return `Action::Follow`. Part of `PolicyExt`.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>
```

--------------------------------

### Job::new Function

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/models/struct.Job.html

Creates a new Job instance with default values. Requires the queue, name, and data for the job.

```rust
pub fn new( queue: impl Into<String>, name: impl Into<String>, data: Value, ) -> Self
```

--------------------------------

### MemoryStorage::new

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/memory/struct.MemoryStorage.html

Creates a new, empty in-memory storage instance.

```APIDOC
## MemoryStorage::new

### Description
Creates a new, empty in-memory storage.

### Method
`new()`

### Returns
- `Self`: A new instance of `MemoryStorage`.
```

--------------------------------

### RustQueue Builders

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueue.html

Methods to create a RustQueue instance with different backend configurations.

```APIDOC
## RustQueue Builders

### `RustQueue::memory()`

**Description**: Creates a builder for an in-memory storage backend. Data is lost when the instance is dropped.

### `RustQueue::redb(path)`

**Description**: Creates a builder for a persistent file-backed backend using redb. The database file is created if it doesn't exist.

### `RustQueue::hybrid(path)`

**Description**: Creates a builder for a hybrid memory+disk storage backend. Reads/writes use an in-memory DashMap, with background snapshots to a redb file.
```

--------------------------------

### Default Implementation for LoggingConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.LoggingConfig.html

Provides a default configuration for LoggingConfig. This is useful when no specific configuration is provided.

```rust
fn default() -> Self
```

--------------------------------

### PartialEq Implementation for SchedulerConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.SchedulerConfig.html

Allows comparing two SchedulerConfig instances for equality. This is useful for testing or verifying configurations.

```rust
fn eq(&self, other: &SchedulerConfig) -> bool
```

--------------------------------

### Initialize Pointer

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/queues/struct.ListQueuesResponse.html

Initializes a memory location with a given initializer and returns its pointer.

```rust
unsafe fn init(init: <T as Pointable>::Init) -> usize
```

--------------------------------

### Clone BufferedRedbConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/storage/buffered_redb/struct.BufferedRedbConfig.html

Allows creating a duplicate of an existing BufferedRedbConfig instance. This is useful for copying configuration settings.

```rust
fn clone(&self) -> BufferedRedbConfig
```

--------------------------------

### List All Known Queues

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueue.html

Lists all known queues along with their current job counts. This provides an overview of the queue system's state.

```rust
pub async fn list_queues(&self) -> Result<Vec<QueueInfo>, RustQueueError>
```

--------------------------------

### Workflow::then

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/struct.Workflow.html

Appends a sequential step to the workflow.

```APIDOC
## Workflow::then

### Description
Append a sequential step.

### Method
```rust
pub fn then(self, step: Arc<dyn WorkflowStep>) -> Self
```
```

--------------------------------

### Create Persistent RustQueue Builder with redb

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/builder/struct.RustQueue.html

Creates a builder for a RustQueue using a persistent redb file. The database file is created if it doesn't exist, and data survives process restarts.

```rust
pub fn redb(path: impl AsRef<Path>) -> Result<RustQueueBuilder>
```

--------------------------------

### Default Implementation for RustQueueConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.RustQueueConfig.html

Provides a default configuration for RustQueueConfig, useful for initialization when a full configuration is not yet available.

```rust
fn default() -> RustQueueConfig
```

--------------------------------

### Clone Implementation for WebhookPayloadData

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/webhook/struct.WebhookPayloadData.html

Provides methods to duplicate or copy the WebhookPayloadData. Use `clone` for a full copy and `clone_from` for in-place assignment.

```rust
fn clone(&self) -> WebhookPayloadData
```

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

--------------------------------

### WithSubscriber

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.SchedulerConfig.html

Methods for attaching subscribers.

```APIDOC
## fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>

### Description
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Method
`with_subscriber`

### Parameters
- `subscriber` (S) - The subscriber to attach, which must be convertible into a `Dispatch`.

### Returns
- `WithDispatch<Self>` - A wrapper containing the original type and the attached subscriber.
```

```APIDOC
## fn with_current_subscriber(self) -> WithDispatch<Self>

### Description
Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Method
`with_current_subscriber`

### Returns
- `WithDispatch<Self>` - A wrapper containing the original type and the attached subscriber.
```

--------------------------------

### push

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/axum_integration/struct.RqState.html

Enqueue a new job, optionally applying JobOptions. Returns the generated JobId.

```APIDOC
## push

Enqueue a new job, optionally applying `JobOptions`.
Returns the generated `JobId`.

### Method

`async fn push(&self, queue: &str, name: &str, data: Value, opts: Option<JobOptions>) -> Result<JobId, RustQueueError>`
```

--------------------------------

### Clone Implementation for AuthConfig

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.AuthConfig.html

Allows creating a duplicate of an AuthConfig instance. Useful for passing configurations around without modifying the original.

```rust
fn clone(&self) -> AuthConfig
```

--------------------------------

### Workflow::fan_out

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/struct.Workflow.html

Appends a parallel fan-out stage with a default array join strategy.

```APIDOC
## Workflow::fan_out

### Description
Append a parallel fan-out stage with default array join.

### Method
```rust
pub fn fan_out(self, steps: Vec<Arc<dyn WorkflowStep>>) -> Self
```
```

--------------------------------

### Workflow::fan_out_with_join

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/struct.Workflow.html

Appends a parallel fan-out stage with a custom fan-in join strategy.

```APIDOC
## Workflow::fan_out_with_join

### Description
Append a parallel fan-out stage with a custom fan-in join strategy.

### Method
```rust
pub fn fan_out_with_join( self, steps: Vec<Arc<dyn WorkflowStep>>, join: Arc<dyn WorkflowJoin>, ) -> Self
```
```

--------------------------------

### Clone Implementation for JobOptions

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/queue/struct.JobOptions.html

Enables creating a duplicate of an existing JobOptions instance.

```rust
fn clone(&self) -> JobOptions
```

--------------------------------

### Append a parallel fan-out stage with default join

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/workflow/struct.Workflow.html

Initiate a parallel execution stage where multiple steps run concurrently. The results are joined using the default array join strategy.

```rust
pub fn fan_out(self, steps: Vec<Arc<dyn WorkflowStep>>) -> Self
```

--------------------------------

### Configure Rate Limit for a Queue

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/rate_limit/struct.QueueRateLimiter.html

Sets the rate limit parameters for a specific queue. Ensures the rate is positive and finite. The burst capacity defaults to the rate if not specified.

```rust
pub fn configure( &self, queue: &str, rate_per_second: f64, burst: Option<u32>, ) -> Result<(), String>
```

--------------------------------

### TryInto for T

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/models/struct.QueueCounts.html

Provides fallible conversion into another type.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.
```

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from type `T` into type `U`.

### Returns
A `Result` containing the converted value of type `U` or an error if the conversion fails.
```

--------------------------------

### Default JobOptions Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/engine/queue/struct.JobOptions.html

Provides a default set of options for a JobOptions struct, useful when most default behaviors are desired.

```rust
fn default() -> JobOptions
```

--------------------------------

### AuthConfig Struct

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/config/struct.AuthConfig.html

Defines the structure for authentication configuration, including whether it's enabled and a list of valid tokens.

```APIDOC
## Struct AuthConfig

rustqueue::config

### Summary

Authentication / authorization settings.

### Fields

- `enabled` (bool) - Whether token-based auth is enforced.
- `tokens` (Vec<String>) - List of valid bearer tokens.
```

--------------------------------

### Generic VZip Implementation

Source: https://docs.rs/rustqueue/0.2.0/rustqueue/api/jobs/struct.DlqResponse.html

Provides vector zipping functionality for compatible types.

```rust
fn vzip(self) -> V
```
Tokens:
Raw