Azums 🦀⚡

A lightweight, high-performance job queue. The optional web dashboard is available as a separate package (azums-dashboard).

azums is an enterprise-grade, transactional background job queue and streaming framework designed for Rust web applications, CLI tools, AI agents, and microservices. Built on top of PostgreSQL, SQLite, Redis, and In-Memory storage backends with native extractors for Axum, Actix Web, Poem, and Rocket.

All backends benchmarked on every commit to main. Zero idle CPU, sub-millisecond wake-up, up to 380k jobs/sec.

⚡ Quickstart ("Hello, World!")

Add azums to your Cargo.toml:

[dependencies]
azums = "0.1"
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Enqueue and process background jobs in under 2 minutes:

use azums::{quickstart, Job};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. Connect to database (Postgres, SQLite, or "memory")
    let client = quickstart("memory").await?;

    // 2. Enqueue background job
    client.enqueue(Job::new("greet", serde_json::json!({"name": "World"}))).await?;

    // 3. Register job processing handler
    client.register_handler("greet", |job| async move {
        println!("Hello, {}!", job.payload["name"]);
        Ok(())
    }).await;

    // 4. Execute workers until queue is empty
    client.run_until_empty().await?;
    Ok(())
}

🆚 Why azums over other job queues?

🔑 Key Differentiators

• One library, any database. Your code looks identical whether you use Postgres, SQLite, or Redis. No lock‑in.
• Zero‑cost idle. Unlike polling‑based Rust queues, azums workers consume no CPU when the queue is empty—saving battery and server costs.
• Natively embedded. Run a full job queue inside your CLI tool, desktop app, or IoT device with SQLite. No external services required.
• Streams without a broker. Durable, replayable event streams are built into the database backend—just like Redis Streams, but your existing database handles it.
• First‑class Rust web framework support. Drop azums-axum into your project and inject a JobQueue directly into route handlers—something no other Rust queue offers.

🔗 See the Live Benchmarks Dashboard for reproducible, up‑to‑date performance numbers.

🏗️ Storage Backend Compatibility

Swap storage backends effortlessly with zero application code changes:

🌐 Native Web Framework Extractors

azums provides native request extractors for every popular Rust web framework:

// Axum route handler with JobQueue extractor
async fn create_user(queue: JobQueue, Json(payload): Json<UserPayload>) -> impl IntoResponse {
    let job_id = queue.enqueue_now("default", "welcome_email", json!(payload)).await?;
    Json(json!({ "status": "queued", "id": job_id }))
}

• azums-axum (Axum 0.7)
• azums-actix (Actix Web 4)
• azums-poem (Poem 3)
• azums-rocket (Rocket 0.5)

⚡ Performance & Micro-Benchmarks

azums is built for maximum throughput with minimal overhead. Run Criterion benchmarks locally:

# Run Criterion micro-benchmarks
cargo bench -p azums

📚 Documentation & Book

• Docs.rs API Guide: Comprehensive module documentation & inline examples.
• Azums Low-Level Design (LLD + DSA): Deep-dive architecture specs, data structures, and algorithm complexity.
• Azums Architecture Book: FOR UPDATE SKIP LOCKED leasing, DLQ sequence diagrams, and table partitioning.

💬 Community & Support

• GitHub Discussions: Have questions, feature requests, or architecture ideas? Join our GitHub Discussions.
• Issue Tracker: Found a bug or issue? Report it on our GitHub Issues tracker.

🤝 Contributing & License

Contributions are welcome! Please read CONTRIBUTING.md and CODE_OF_CONDUCT.md.

Licensed under either of Apache License, Version 2.0 or MIT License at your option.