riverqueue/river

Features

• Persistent Job Queue Libraries - Provides a reliable task processing library for Go that uses a relational database for durable state management.
• Transactional Enqueueing - Links job insertion and completion to a database transaction to ensure strict atomicity with application data.
• Database-Backed Deferred Queues - Uses a relational database to persist job states and metadata, ensuring atomicity and durability through database transactions.
• Transactional Updates - Updates job status and metadata within the same database transaction as the primary business logic to ensure strict consistency.
• Database Backend Integration - Connects to PostgreSQL backends using native or poll-only modes to store queue data.
• Job State Persistence - Persists job output or metadata partway through a running function to enable resumption from checkpoints.
• PostgreSQL Task Queues - Uses PostgreSQL as the primary engine for job persistence, transactional enqueuing, and state management.
• Asynchronous Task Processing - Offloads heavy computations and external API calls to background workers to keep the main application responsive.
• Step-Level Checkpoints - Persists task execution state after each step to allow long-running work to resume from the last checkpoint after failure.
• Leadership Transfers - Orchestrates the transfer of the coordinator leader role between nodes in a cluster.
• Resumable Workflow Definitions - Deno River breaks long-running tasks into persisted steps to skip completed work after a restart.
• Distributed Job Schedulers - Implements a coordinator model with leader election to manage periodic and delayed tasks across a cluster.
• Distributed Leader Election - Implements a coordinator model with leader election to manage periodic job triggering and prevent duplicate execution across a cluster.
• Job Checkpointing - Saves the current step and cursor of a resumable job within a database transaction for recovery.
• Job Queues - Implements a system for managing and routing asynchronous tasks into named queues for execution.
• Distributed Job Schedulers with Web UI - Manages recurring tasks and delayed jobs across a cluster of workers with a coordinator model and web interface.
• Transactional Job Completion - Marks jobs as finished within the same database transaction used for the primary business logic modifications.
• Transactional Queues - Ensures background tasks are enqueued within the same database transaction as application data to maintain consistency.
• Checkpoint-Based Resumptions - Provides a resumable task framework that tracks progress via checkpoints to resume long-running work after failures.
• Multi-Step Job Tracking - Tracks progress of multi-step tasks and skips completed steps to resume execution after a failure.
• Resumable Task Frameworks - Functions as a resumable task framework allowing long-running background work to be broken into persisted steps.
• Task Progress Cursors - Deno River records a state or position within a step so a retry can resume from that point.
• Transactional State Persistence - Deno River records the completion of a specific step within a database transaction to save progress.
• JSON Persistence - Stores task arguments and execution results as JSON blobs to enable language-agnostic job processing and introspection.
• Atomic Duplicate Prevention - Prevents duplicate jobs from being enqueued based on arguments or time windows using atomic checks.
• Future-Time Executions - Defines specific future timestamps for tasks to be executed instead of immediate processing.
• Queue Pause and Resume Controls - Allows temporarily stopping the processing of tasks within a specific queue until manually resumed.
• Workload Isolation - Segregates tasks into named queues to control throughput and prevent low-priority jobs from blocking critical work.
• Delayed Executions - Allows setting a future timestamp for a job to run, keeping it inactive until that moment.
• Priority-Based Job Schedulers - Configures task parameters including retry limits, priority levels, and target queues.
• Job Cancellation - Prevents a job from executing again by returning a specific cancellation error during processing.
• Job Event Notifications - Provides real-time notifications when background jobs reach specific lifecycle states, such as successful completion.
• Job Timeout Enforcements - Specifies the maximum duration a job can run before its context is automatically cancelled.
• Recurring Job Scheduling - Manages recurring tasks and executes specific logic when a new cluster leader is elected.
• Job Middleware - Wraps job execution in a sequence of functions to inject shared logic and telemetry across all tasks.
• Exponential Backoff Retries - Calculates the delay before retrying a failed job using policies like exponential backoff.
• Background Job Definitions - Allows specifying identifiers and arguments for units of work to ensure correct routing to workers.
• Job Deferrals - Provides the ability to postpone background tasks for a set duration without incrementing failure counts.
• Job Snoozing - Implements job snoozing to schedule retries after a specified duration without counting them as failed attempts.
• Stuck Job Detection - Detects jobs that exceed time thresholds and triggers handlers to free worker slots.
• Fixed Interval Schedulers - Deno River executes tasks on a fixed time interval and allows dynamic updates while running.
• Functional Job Handlers - Registers background task handlers using simple functions instead of complex structures.
• Worker Task Mapping - Maps specific job types to handler functions that execute the task logic upon dequeuing.
• Handler Middlewares - Wraps job handlers in a chain of middleware functions to inject cross-cutting concerns like telemetry and logging.
• Cross-Language Job Enqueueing - Allows tasks to be inserted into the queue from various programming languages to be processed by a Go worker.
• Task Lifecycle Interceptions - Provides middleware hooks to modify job payloads before enqueuing or wrap execution logic for error handling.
• Retry Policies - Defines when a failed job should be attempted again based on its properties or attempt count.
• Job Execution Logging - Records the success, failure, and detailed output logs of background task executions for monitoring.
• Execution Duration Tracking - Records the time a job spent waiting and its total execution duration to monitor performance.
• Telemetry Exporters - Exports internal job statistics, logs, and performance metrics to third-party observability platforms.
• Queue Management Interfaces - Ships a web interface to view, manage, and interact with the current state of jobs and queues.
• Job - Processes errors and panics during execution to determine if a job should be retried.
• Job Lifecycle Hooks - Defines custom logic callbacks that execute at specific stages of a job's lifecycle based on its type.
• Job Queues - High-performance job processing system for Go.
• General Purpose Orchestration - Postgres-backed workflow engine for background job processing in Go.

Star-Verlauf