Sidekiq Job Architecture

graph TB
    subgraph "Client Side"
        App[Ruby Application]
        Client[Sidekiq::Client]
    end

    subgraph "Sidekiq Server Process"
        CLI[Sidekiq::CLI]
        Config[Sidekiq::Config]
        Launcher[Sidekiq::Launcher]
        Manager[Sidekiq::Manager]
        Poller[Sidekiq::Scheduled::Poller]
        Processor[Sidekiq::Processor]
        Job[Sidekiq::Job]
        MiddlewareChain[Middleware::Chain]
        BasicFetch[Sidekiq::BasicFetch]
    end

    subgraph "Storage"
        Redis[Redis/Valkey/Dragonfly]
    end

    subgraph "Web Interface"
        WebUI[Sidekiq::Web UI]
        API[Sidekiq::API]
    end

    App -->|enqueues jobs| Client
    Client -->|pushes to| Redis

    CLI -->|starts| Launcher
    CLI -->|configures| Config
    Config -.->|configures| Launcher

    Launcher -->|manages| Manager
    Launcher -->|schedules| Poller
    Manager -->|manages| Processor

    Poller -->|enqueues due jobs| Redis
    Redis -->|fetches jobs| BasicFetch
    BasicFetch -->|provides work to| Processor
    MiddlewareChain -->|wraps| Processor
    Processor -->|executes| Job

    WebUI -->|uses| API
    API -->|reads from| Redis
    WebUI -->|monitors| Redis

    Manager -->|pushes to| Redis
    Processor -->|fetches jobs| Redis

sequenceDiagram
    participant App as Ruby Application
    participant Client as Sidekiq::Client
    participant Middleware as Client Middleware
    participant Redis as Redis
    participant Poller as Scheduled::Poller
    participant Manager as Manager
    participant Processor as Processor
    participant ServerMW as Server Middleware
    participant Worker as Worker Class

    Note over App, Worker: Client-Side (Job Enqueuing)

    App->>Client: perform_async(*args)
    Client->>Middleware: invoke middleware chain
    Middleware->>Redis: LPUSH to queue

    Note over App, Worker: OR Schedule for later

    App->>Client: perform_in(time, *args)
    Client->>Redis: ZADD to scheduled set

    Note over App, Worker: Server-Side (Job Processing)

    loop Continuous polling
        Poller->>Redis: Check scheduled/retry sets
        Poller->>Redis: Move due jobs to queues
    end

    Manager->>Processor: start worker
    Processor->>Redis: BRPOP from queue
    Redis-->>Processor: job payload
    Processor->>ServerMW: invoke middleware chain
    ServerMW->>Worker: perform(*args)

    alt Success
        Worker-->>ServerMW: [Success]
        ServerMW-->>Processor: return result
        Processor->>Manager: report success
    else Failure
        Worker-->>ServerMW: [Failure]
        ServerMW-->>Processor: raise exception
        Processor->>Redis: Schedule retry or move to dead
    end

See also Amdahl’s Law