tessl/pypi-rq-dashboard

A lightweight web interface to monitor RQ queues, jobs, and workers in realtime

—

Pending

Overview

Eval results

Files

Flask Integration

Name: tessl/pypi-rq-dashboard
Author: tessl

Flask blueprint for embedding RQ Dashboard into existing Flask applications. Provides complete web interface with HTML views and REST API endpoints for monitoring RQ queues, jobs, and workers.

Capabilities

Blueprint Registration

Main Flask blueprint providing the complete RQ Dashboard web interface.

blueprint: Blueprint
    """
    Main Flask blueprint for RQ Dashboard web interface.
    
    Blueprint name: "rq_dashboard"
    Includes templates and static files for web interface.
    """

Basic integration:

from flask import Flask
from rq_dashboard import blueprint

app = Flask(__name__)
app.register_blueprint(blueprint, url_prefix='/rq')

Configuration Setup

Default configuration settings for Flask applications.

default_settings: object
    """
    Default Flask configuration settings.
    Contains DEBUG = False and other basic settings.
    """

Usage:

from flask import Flask
from rq_dashboard import blueprint, default_settings

app = Flask(__name__)
app.config.from_object(default_settings)
app.config['RQ_DASHBOARD_REDIS_URL'] = 'redis://localhost:6379'
app.register_blueprint(blueprint)

Redis Connection Setup

Establishes Redis connections for RQ operations within Flask applications.

def setup_rq_connection(current_app):
    """
    Set up Redis connection for RQ operations.
    
    Configures Redis connection based on RQ_DASHBOARD_REDIS_URL setting.
    Supports single Redis instance or multiple instances for monitoring.
    Handles Redis Sentinel configurations.
    
    Args:
        current_app: Flask application instance with configuration
        
    Raises:
        RuntimeError: If no Redis configuration is provided
    """

Configuration Management

Configuration container for RQ Dashboard settings and serialization.

class Config:
    """
    Configuration container for RQ Dashboard settings.
    
    Attributes:
        serializer: RQ serializer instance (default: DefaultSerializer)
    """
    serializer: Any

Global configuration instance:

config: Config
    """Global configuration instance for RQ Dashboard."""

HTML Routes

Queue Management Views

def queues_overview(instance_number):
    """
    Display queues overview page.
    
    Args:
        instance_number: Redis instance index (0-based)
        
    Returns:
        Response: HTML page showing all queues with counts and links
    """

def jobs_overview(instance_number, queue_name, registry_name, per_page, order, page):
    """
    Display jobs overview page with pagination.
    
    Args:
        instance_number: Redis instance index
        queue_name: Name of the queue to display
        registry_name: Registry type ('queued', 'failed', 'finished', etc.)
        per_page: Number of jobs per page
        order: Sort order ('asc' or 'desc')
        page: Page number (1-based)
        
    Returns:
        Response: HTML page showing jobs list with pagination
    """

def job_view(instance_number, job_id):
    """
    Display individual job details page.
    
    Args:
        instance_number: Redis instance index
        job_id: Unique identifier for the job
        
    Returns:
        Response: HTML page showing detailed job information
    """

Worker Management Views

def workers_overview(instance_number):
    """
    Display workers overview page.
    
    Args:
        instance_number: Redis instance index
        
    Returns:
        Response: HTML page showing all workers with status and statistics
    """

JSON API Endpoints

Data Retrieval

def list_queues(instance_number):
    """
    Get all queues as JSON.
    
    Args:
        instance_number: Redis instance index
        
    Returns:
        dict: JSON response with queues data including counts and URLs
    """

def list_jobs(instance_number, queue_name, registry_name, per_page, order, page):
    """
    Get jobs list as JSON with pagination.
    
    Args:
        instance_number: Redis instance index
        queue_name: Name of the queue
        registry_name: Registry type
        per_page: Jobs per page
        order: Sort order
        page: Page number
        
    Returns:
        dict: JSON response with jobs data and pagination info
    """

def job_info(instance_number, job_id):
    """
    Get detailed job information as JSON.
    
    Args:
        instance_number: Redis instance index
        job_id: Job identifier
        
    Returns:
        dict: JSON response with complete job details
    """

def list_workers(instance_number):
    """
    Get all workers as JSON.
    
    Args:
        instance_number: Redis instance index
        
    Returns:
        dict: JSON response with workers data including status and statistics
    """

Job Management Actions

def delete_job_view(job_id, registry=None):
    """
    Delete a specific job (POST endpoint).
    
    Args:
        job_id: Job identifier to delete
        registry: Optional registry instance for cleanup
        
    Returns:
        dict: JSON response with operation status
    """

def requeue_job_view(job_id):
    """
    Requeue a specific job (POST endpoint).
    
    Args:
        job_id: Job identifier to requeue
        
    Returns:
        dict: JSON response with operation status
    """

def requeue_all(queue_name):
    """
    Requeue all failed jobs in a queue (GET/POST endpoint).
    
    Args:
        queue_name: Name of the queue to requeue jobs from
        
    Returns:
        dict: JSON response with operation status and count of requeued jobs
    """

Queue Management Actions

def empty_queue(queue_name, registry_name):
    """
    Empty a queue or registry (POST endpoint).
    
    Args:
        queue_name: Name of the queue
        registry_name: Registry type to empty
        
    Returns:
        dict: JSON response with operation status
    """

def compact_queue(queue_name):
    """
    Compact a queue to remove completed jobs (POST endpoint).
    
    Args:
        queue_name: Name of the queue to compact
        
    Returns:
        dict: JSON response with operation status
    """

Integration Examples

Basic Integration

from flask import Flask
from rq_dashboard import blueprint, default_settings

app = Flask(__name__)

# Apply default configuration
app.config.from_object(default_settings)

# Configure Redis connection
app.config['RQ_DASHBOARD_REDIS_URL'] = 'redis://localhost:6379'

# Register blueprint
app.register_blueprint(blueprint, url_prefix='/rq')

if __name__ == '__main__':
    app.run(debug=True)

Multiple Redis Instances

from flask import Flask
from rq_dashboard import blueprint, default_settings

app = Flask(__name__)
app.config.from_object(default_settings)

# Configure multiple Redis instances
app.config['RQ_DASHBOARD_REDIS_URL'] = [
    'redis://redis1:6379',
    'redis://redis2:6379',
    'redis://redis3:6379'
]

app.register_blueprint(blueprint, url_prefix='/monitoring/rq')

With Authentication

from flask import Flask, request, Response
from rq_dashboard import blueprint, default_settings

app = Flask(__name__)
app.config.from_object(default_settings)
app.config['RQ_DASHBOARD_REDIS_URL'] = 'redis://localhost:6379'

# Add authentication to blueprint
@blueprint.before_request
def require_auth():
    auth = request.authorization
    if not auth or auth.username != 'admin' or auth.password != 'secret':
        return Response(
            'Authentication required',
            401,
            {'WWW-Authenticate': 'Basic realm="RQ Dashboard"'}
        )

app.register_blueprint(blueprint, url_prefix='/rq')

Custom Configuration

from flask import Flask
from rq_dashboard import blueprint, default_settings
from rq_dashboard.web import setup_rq_connection

app = Flask(__name__)
app.config.from_object(default_settings)

# Custom configuration
app.config.update({
    'RQ_DASHBOARD_REDIS_URL': 'redis://localhost:6379',
    'RQ_DASHBOARD_POLL_INTERVAL': 5000,  # 5 seconds
    'RQ_DASHBOARD_DISABLE_DELETE': True,  # Disable job deletion
})

# Setup Redis connection
setup_rq_connection(app)

app.register_blueprint(blueprint)

Configuration Options

Required Settings

# Single Redis instance
app.config['RQ_DASHBOARD_REDIS_URL'] = 'redis://localhost:6379'

# Multiple Redis instances
app.config['RQ_DASHBOARD_REDIS_URL'] = [
    'redis://localhost:6379',
    'redis://localhost:6380'
]

Optional Settings

# Polling interval in milliseconds (default: 2500)
app.config['RQ_DASHBOARD_POLL_INTERVAL'] = 5000

# Disable delete operations (default: False)
app.config['RQ_DASHBOARD_DISABLE_DELETE'] = True

# Redis Sentinel password (optional)
app.config['RQ_DASHBOARD_REDIS_SENTINEL_PASSWORD'] = 'sentinel_password'

# Redis instance password (optional)
app.config['RQ_DASHBOARD_REDIS_PASSWORD'] = 'redis_password'

URL Structure

When registered with url_prefix='/rq':

/rq/ - Main queues overview
/rq/0/view/queues - Queues for Redis instance 0
/rq/0/view/workers - Workers for Redis instance 0
/rq/0/view/jobs - Jobs overview
/rq/0/data/queues.json - Queues data API
/rq/job/{job_id}/delete - Delete job action
/rq/job/{job_id}/requeue - Requeue job action

Install with Tessl CLI

npx tessl i tessl/pypi-rq-dashboard

docs

tessl/pypi-rq-dashboard