🔍1. Fundamentals & Core Concepts

Delayed::Job is a database-backed job queue for Ruby that provides a simple and reliable way to handle background job processing. It stores jobs in your application’s database and processes them using worker processes.

What is Delayed::Job?

Delayed::Job is a background job processing system that allows you to move time-consuming tasks out of your main application flow. It stores jobs in your database and processes them using worker processes, making your application more responsive and scalable without requiring additional infrastructure like Redis.

Why Use Delayed::Job?

• ✅ To perform tasks asynchronously (emails, notifications)
• ✅ To avoid blocking the main web request/response cycle
• ✅ To increase app responsiveness and user experience
• ✅ To retry failed jobs automatically
• ✅ To improve scalability and performance
• ✅ When you want to avoid additional infrastructure
• ✅ When you need ACID compliance for job processing

Delayed::Job Architecture

Key Components

• Database: Your application’s database for job storage
• Workers: Separate processes that execute jobs
• delayed_jobs table: Database table that holds pending jobs
• Jobs: Ruby objects that implement perform method
• ActiveRecord: ORM for database interactions

⚙️2. Installation & Setup

Prerequisites

• Ruby: 2.0 or higher
• Rails: 4.0 or higher (optional but recommended)
• Database: Any database supported by ActiveRecord
• ActiveRecord: For database interactions

Installation Steps

1. Add Delayed::Job to Gemfile

# Gemfile
gem 'delayed_job'
gem 'delayed_job_active_record'  # For ActiveRecord backend
gem 'delayed_job_web'            # Optional: for Web UI

2. Install Gems

bundle install

3. Generate Migration

# Generate the delayed_jobs table
rails generate delayed_job:install

# This creates a migration file like:
# db/migrate/YYYYMMDDHHMMSS_create_delayed_jobs.rb

4. Run Migration

rails db:migrate

5. Create Delayed::Job Configuration

# config/initializers/delayed_job.rb
Delayed::Job.destroy_failed_jobs = false
Delayed::Job.max_attempts = 3
Delayed::Job.max_run_time = 5.minutes

# Optional: Configure logging
Delayed::Job.logger = Rails.logger

# Optional: Configure queue names
Delayed::Job.queue_name = 'default'

Rails Integration

Add to Application

# config/application.rb
module YourApp
  class Application < Rails::Application
    # ... existing code ...
    
    # Configure Delayed::Job as ActiveJob backend
    config.active_job.queue_adapter = :delayed_job
  end
end

Create Procfile

# Procfile
web: bundle exec rails server
worker: bundle exec rake jobs:work

Database Schema

Delayed Jobs Table Structure

# The migration creates a table with these columns:
create_table :delayed_jobs, force: true do |t|
  t.integer  :priority, default: 0, null: false
  t.integer  :attempts, default: 0, null: false
  t.text     :handler,                 null: false
  t.text     :last_error
  t.datetime :run_at
  t.datetime :locked_at
  t.datetime :failed_at
  t.string   :locked_by
  t.string   :queue
  t.datetime :created_at
  t.datetime :updated_at
end

add_index :delayed_jobs, [:priority, :run_at], name: 'delayed_jobs_priority'

Environment Setup

Environment Variables

# .env
DATABASE_URL=postgresql://localhost/your_app
RAILS_ENV=development
QUEUE=default,high,low

Development Setup

# Start Rails server
rails server

# Start Delayed::Job worker (in separate terminal)
bundle exec rake jobs:work

# Or with specific queue
bundle exec rake jobs:work QUEUE=high,default

Verification

Test Database Connection

# In Rails console
rails console

# Test database connection
ActiveRecord::Base.connection.execute("SELECT 1")
# Should return a result

Test Job Enqueue

# Create a test job
class TestJob
  def perform
    puts "Test job executed!"
  end
end

# Enqueue the job
Delayed::Job.enqueue(TestJob.new)
# Should return a Delayed::Job instance

Common Setup Issues

🚀3. Basic Usage & Workers

Creating Jobs

Basic Job Structure

class EmailJob
  def perform(user_id, message)
    user = User.find(user_id)
    UserMailer.notification(user, message).deliver_now
  end
end

Job with Error Handling

class DataProcessingJob
  def perform(data_id)
    data = Data.find(data_id)
    
    begin
      # Process the data
      data.process!
      data.update(status: 'processed')
    rescue => e
      data.update(status: 'failed', error: e.message)
      raise e  # Re-raise to trigger retry
    end
  end
end

Job with Priority

class HighPriorityJob
  def perform
    # High priority work
  end
end

# Enqueue with high priority
Delayed::Job.enqueue(HighPriorityJob.new, priority: 10)

Enqueueing Jobs

Basic Enqueue

# Enqueue immediately
Delayed::Job.enqueue(EmailJob.new(user.id, "Hello!"))

# Enqueue with delay
Delayed::Job.enqueue(EmailJob.new(user.id, "Hello!"), run_at: 1.hour.from_now)

# Enqueue with priority
Delayed::Job.enqueue(EmailJob.new(user.id, "Hello!"), priority: 5)

Using ActiveJob

class EmailJob < ApplicationJob
  queue_as :default
  
  def perform(user_id, message)
    user = User.find(user_id)
    UserMailer.notification(user, message).deliver_now
  end
end

# Enqueue using ActiveJob
EmailJob.perform_later(user.id, "Hello!")
EmailJob.set(wait: 1.hour).perform_later(user.id, "Hello!")

Worker Management

Starting Workers

# Start worker for all queues
bundle exec rake jobs:work

# Start worker for specific queues
bundle exec rake jobs:work QUEUE=high,default

# Start multiple workers
bundle exec rake jobs:work QUEUE=high,default COUNT=3

# Start worker in background
nohup bundle exec rake jobs:work > worker.log 2>&1 &

Worker Configuration

# config/initializers/delayed_job.rb
Delayed::Job.destroy_failed_jobs = false
Delayed::Job.max_attempts = 3
Delayed::Job.max_run_time = 5.minutes
Delayed::Job.sleep_delay = 5
Delayed::Job.read_ahead = 5

# Configure logging
Delayed::Job.logger = Rails.logger
Delayed::Job.logger.level = Logger::INFO

Job Lifecycle

Error Handling

Retry Configuration

# Global retry settings
Delayed::Job.max_attempts = 3
Delayed::Job.destroy_failed_jobs = false

# Per-job retry settings
class RetryableJob
  def perform
    # Job logic
  end
  
  def max_attempts
    5  # Override global setting
  end
end

Custom Error Handling

class RobustJob
  def perform
    begin
      # Main job logic
      process_data
    rescue NetworkError => e
      # Retry network errors
      raise e
    rescue ValidationError => e
      # Don't retry validation errors
      log_error(e)
      return
    end
  end
  
  def max_attempts
    3
  end
  
  private
  
  def log_error(error)
    Rails.logger.error("Job failed: #{error.message}")
  end
end

Monitoring Workers

Check Worker Status

# Check running workers
ps aux | grep delayed_job

# Check job counts
Delayed::Job.count
Delayed::Job.where(failed_at: nil).count
Delayed::Job.where.not(failed_at: nil).count

# Check queue lengths
Delayed::Job.group(:queue).count

Worker Health Check

# Check if workers are processing
Delayed::Job.where('locked_at > ?', 10.minutes.ago).count

# Check for stuck jobs
Delayed::Job.where('locked_at < ?', 1.hour.ago).count

# Check failed jobs
Delayed::Job.where.not(failed_at: nil).count

📋4. Queue Management & Priority

Queue Concepts

Delayed::Job uses a single table for all jobs but supports queue names and priorities to organize job processing. Jobs are processed in order of priority (lower numbers = higher priority) and then by creation time.

Queue Configuration

Setting Queue Names

# Enqueue to specific queue
Delayed::Job.enqueue(EmailJob.new, queue: 'emails')

# Using ActiveJob
class EmailJob < ApplicationJob
  queue_as :emails
end

# Enqueue with queue
EmailJob.set(queue: 'high_priority').perform_later

Priority Levels

# High priority (processed first)
Delayed::Job.enqueue(Job.new, priority: 0)

# Normal priority
Delayed::Job.enqueue(Job.new, priority: 10)

# Low priority (processed last)
Delayed::Job.enqueue(Job.new, priority: 20)

Worker Queue Assignment

Processing Specific Queues

# Process all queues
bundle exec rake jobs:work

# Process specific queues
bundle exec rake jobs:work QUEUE=high,default

# Process single queue
bundle exec rake jobs:work QUEUE=emails

# Process multiple queues with priority
bundle exec rake jobs:work QUEUE=high,default,low

Queue Monitoring

# Check queue lengths
Delayed::Job.group(:queue).count

# Check jobs by priority
Delayed::Job.group(:priority).count

# Check failed jobs by queue
Delayed::Job.where.not(failed_at: nil).group(:queue).count

# Check stuck jobs by queue
Delayed::Job.where('locked_at < ?', 1.hour.ago).group(:queue).count

Advanced Queue Management

Queue-specific Workers

# Start dedicated email worker
bundle exec rake jobs:work QUEUE=emails COUNT=2

# Start high-priority worker
bundle exec rake jobs:work QUEUE=high COUNT=1

# Start background worker
bundle exec rake jobs:work QUEUE=default,low COUNT=3

Queue Cleanup

# Clean up old completed jobs
Delayed::Job.where('created_at < ?', 30.days.ago).delete_all

# Clean up failed jobs
Delayed::Job.where.not(failed_at: nil).delete_all

# Clean up stuck jobs
Delayed::Job.where('locked_at < ?', 1.hour.ago).update_all(locked_at: nil, locked_by: nil)

Best Practices

🔧5. Monitoring & Web UI

Built-in Monitoring

Database Queries

# Check overall job status
Delayed::Job.count
Delayed::Job.where(failed_at: nil).count
Delayed::Job.where.not(failed_at: nil).count

# Check queue status
Delayed::Job.group(:queue).count

# Check priority distribution
Delayed::Job.group(:priority).count

# Check processing status
Delayed::Job.where.not(locked_at: nil).count
Delayed::Job.where('locked_at < ?', 10.minutes.ago).count

Worker Status

# Check running workers
ps aux | grep delayed_job

# Check worker processes
pgrep -f "delayed_job"

# Check worker logs
tail -f log/delayed_job.log

Web UI Setup

Install delayed_job_web

# Add to Gemfile
gem 'delayed_job_web'

# Install
bundle install

Configure Routes

# config/routes.rb
Rails.application.routes.draw do
  # ... existing routes ...
  
  # Mount the web UI
  mount DelayedJobWeb => '/delayed_job'
end

Access Web UI

# Start Rails server
rails server

# Access web UI at:
# http://localhost:3000/delayed_job

Custom Monitoring

Health Check Endpoint

# app/controllers/health_controller.rb
class HealthController < ApplicationController
  def delayed_job
    stats = {
      total_jobs: Delayed::Job.count,
      pending_jobs: Delayed::Job.where(failed_at: nil).count,
      failed_jobs: Delayed::Job.where.not(failed_at: nil).count,
      running_workers: `ps aux | grep delayed_job | grep -v grep | wc -l`.strip.to_i
    }
    
    render json: stats
  end
end

Monitoring Dashboard

# app/controllers/admin/dashboard_controller.rb
class Admin::DashboardController < ApplicationController
  def delayed_job
    @stats = {
      total_jobs: Delayed::Job.count,
      pending_jobs: Delayed::Job.where(failed_at: nil).count,
      failed_jobs: Delayed::Job.where.not(failed_at: nil).count,
      queue_stats: Delayed::Job.group(:queue).count,
      priority_stats: Delayed::Job.group(:priority).count
    }
  end
end

Logging Configuration

Configure Logging

# config/initializers/delayed_job.rb
Delayed::Job.logger = Rails.logger
Delayed::Job.logger.level = Logger::INFO

# Custom log format
Delayed::Job.logger.formatter = proc do |severity, datetime, progname, msg|
  "[#{datetime}] #{severity}: #{msg}\n"
end

Log Levels

# Development - verbose logging
Delayed::Job.logger.level = Logger::DEBUG

# Production - minimal logging
Delayed::Job.logger.level = Logger::WARN

# Custom logging
Delayed::Job.logger.info("Worker started")
Delayed::Job.logger.error("Job failed: #{error.message}")

Alerting

Failed Job Alerts

# config/initializers/delayed_job.rb
Delayed::Job.after_failure do |job, error|
  # Send alert
  AlertService.notify("Job failed: #{job.id} - #{error.message}")
end

Queue Monitoring

# Check queue health
def check_queue_health
  failed_count = Delayed::Job.where.not(failed_at: nil).count
  stuck_count = Delayed::Job.where('locked_at < ?', 1.hour.ago).count
  
  if failed_count > 100
    AlertService.notify("High failed job count: #{failed_count}")
  end
  
    if stuck_count > 50
    AlertService.notify("Jobs stuck: #{stuck_count}")
  end
end

📊6. Advanced Features

Job Scheduling

Delayed Execution

# Execute after 1 hour
Delayed::Job.enqueue(Job.new, run_at: 1.hour.from_now)

# Execute at specific time
Delayed::Job.enqueue(Job.new, run_at: Time.parse('2024-01-01 09:00:00'))

# Execute every day at 9 AM
class DailyJob
  def perform
    # Job logic
  end
  
  def self.schedule_daily
    Delayed::Job.enqueue(new, run_at: Time.current.beginning_of_day + 9.hours)
  end
end

Recurring Jobs

# Simple recurring job
class RecurringJob
  def perform
    # Job logic
    
    # Schedule next execution
    Delayed::Job.enqueue(self.class.new, run_at: 1.hour.from_now)
  end
end

# Start recurring job
Delayed::Job.enqueue(RecurringJob.new, run_at: 1.hour.from_now)

Job Serialization

Complex Objects

# Jobs with complex parameters
class ComplexJob
  def initialize(user, options = {})
    @user = user
    @options = options
  end
  
  def perform
    # Access instance variables
    user = @user
    options = @options
    
    # Job logic
  end
end

# Enqueue with complex object
user = User.find(1)
Delayed::Job.enqueue(ComplexJob.new(user, {priority: 'high'}))

ActiveRecord Objects

# Jobs with ActiveRecord objects
class UserNotificationJob
  def initialize(user_id)
    @user_id = user_id
  end
  
  def perform
    user = User.find(@user_id)
    # Job logic with user
  end
end

# Enqueue with user ID
Delayed::Job.enqueue(UserNotificationJob.new(user.id))

Custom Job Classes

Job with Custom Methods

class AdvancedJob
  def perform
    # Main job logic
    process_data
  end
  
  def max_attempts
    5  # Custom retry attempts
  end
  
  def max_run_time
    10.minutes  # Custom timeout
  end
  
  def queue_name
    'high_priority'  # Custom queue
  end
  
  private
  
  def process_data
    # Complex processing logic
  end
end

Job with Callbacks

class CallbackJob
  def perform
    # Job logic
  end
  
  def before(job)
    Rails.logger.info("Starting job #{job.id}")
  end
  
  def after(job)
    Rails.logger.info("Completed job #{job.id}")
  end
  
  def error(job, exception)
    Rails.logger.error("Job #{job.id} failed: #{exception.message}")
  end
end

Performance Optimization

Database Optimization

# Add database indexes
add_index :delayed_jobs, [:priority, :run_at]
add_index :delayed_jobs, [:queue, :priority, :run_at]
add_index :delayed_jobs, [:locked_at, :locked_by]
add_index :delayed_jobs, [:failed_at]

# Configure read_ahead
Delayed::Job.read_ahead = 10

# Configure sleep_delay
Delayed::Job.sleep_delay = 5

Worker Optimization

# Start multiple workers
bundle exec rake jobs:work COUNT=4

# Use different queues for different workers
# Worker 1: High priority jobs
bundle exec rake jobs:work QUEUE=high COUNT=2

# Worker 2: Background jobs
bundle exec rake jobs:work QUEUE=default,low COUNT=3

Integration with ActiveJob

ActiveJob Configuration

# config/application.rb
config.active_job.queue_adapter = :delayed_job

# Use ActiveJob features
class EmailJob < ApplicationJob
  queue_as :emails
  
  def perform(user_id, message)
    # Job logic
  end
end

# Enqueue with ActiveJob
EmailJob.perform_later(user.id, "Hello!")
EmailJob.set(wait: 1.hour).perform_later(user.id, "Hello!")
EmailJob.set(queue: 'high').perform_later(user.id, "Hello!")

Custom ActiveJob Adapter

# lib/active_job/queue_adapters/delayed_job_adapter.rb
module ActiveJob
  module QueueAdapters
    class DelayedJobAdapter
      def enqueue(job)
        Delayed::Job.enqueue(job, queue: job.queue_name)
      end
      
      def enqueue_at(job, timestamp)
        Delayed::Job.enqueue(job, run_at: Time.at(timestamp))
      end
    end
  end
end

🔥7. Troubleshooting & Best Practices

Common Issues

Jobs Not Processing

Jobs Stuck in Database

High Memory Usage

Performance Issues

Slow Job Processing

# Check for slow jobs
Delayed::Job.where('locked_at > ?', 10.minutes.ago).count

# Optimize database queries
add_index :delayed_jobs, [:priority, :run_at]

# Increase worker count
bundle exec rake jobs:work COUNT=4

# Use dedicated workers for slow jobs
bundle exec rake jobs:work QUEUE=slow_jobs COUNT=2

Database Bottleneck

# Monitor database performance
Delayed::Job.where('created_at > ?', 1.hour.ago).count

# Optimize read_ahead setting
Delayed::Job.read_ahead = 5

# Use connection pooling
Delayed::Job.connection_pool = ActiveRecord::Base.connection_pool

Monitoring & Debugging

Job Debugging

# Check job details
job = Delayed::Job.find(job_id)
puts job.handler
puts job.last_error
puts job.attempts

# Check job payload
job_object = YAML.load(job.handler)
puts job_object.class
puts job_object.instance_variables

Worker Debugging

# Check worker logs
tail -f log/delayed_job.log

# Check worker processes
ps aux | grep delayed_job

# Check worker status
Delayed::Job.where.not(locked_at: nil).group(:locked_by).count

Best Practices

Security Considerations

Job Security

# Validate job parameters
class SecureJob
  def initialize(user_id, data)
    @user_id = user_id
    @data = data
  end
  
  def perform
    # Validate inputs
    user = User.find(@user_id)
    raise "Unauthorized" unless user.can_perform_action?
    
    # Process with validated data
    process_secure_data(@data)
  end
  
  private
  
  def process_secure_data(data)
    # Sanitize and process data
  end
end

Worker Security

# Run workers with limited permissions
# Use dedicated user for workers
sudo -u delayed_job_user bundle exec rake jobs:work

# Set up firewall rules
# Limit database access for workers

# Use environment-specific configurations
Delayed::Job.logger.level = Logger::WARN if Rails.env.production?

🚨8. Interview Questions & Answers

Basic Questions

Intermediate Questions

Advanced Questions

System Design Questions

❓9. Real-World Case Studies

E-commerce Platform

Challenge

A large e-commerce platform needed to process order confirmations, inventory updates, and customer notifications without blocking the main application.

Solution

# Order processing jobs
class OrderConfirmationJob
  def perform(order_id)
    order = Order.find(order_id)
    OrderMailer.confirmation(order).deliver_now
    InventoryService.update_stock(order)
  end
end

class InventoryUpdateJob
  def perform(product_id)
    product = Product.find(product_id)
    product.update_stock_levels
    product.notify_low_stock if product.low_stock?
  end
end

# Queue configuration
bundle exec rake jobs:work QUEUE=high COUNT=2      # Order confirmations
bundle exec rake jobs:work QUEUE=default COUNT=3   # General processing
bundle exec rake jobs:work QUEUE=low COUNT=1       # Background tasks

Results

• Reduced order processing time from 5 seconds to 200ms
• Handled 10,000+ orders per day
• Improved customer experience with immediate order confirmation
• Reliable inventory management with automatic retries

Content Management System

Challenge

A CMS needed to process large file uploads, generate thumbnails, and send notifications without impacting user experience.

Solution

# File processing jobs
class FileProcessingJob
  def perform(file_id)
    file = FileUpload.find(file_id)
    
    # Generate thumbnails
    file.generate_thumbnails
    
    # Update file status
    file.update(status: 'processed')
    
    # Notify user
    NotificationJob.perform_later(file.user_id, "File processed")
  end
end

class NotificationJob
  def perform(user_id, message)
    user = User.find(user_id)
    UserMailer.notification(user, message).deliver_now
  end
end

# Worker configuration
bundle exec rake jobs:work QUEUE=file_processing COUNT=3
bundle exec rake jobs:work QUEUE=notifications COUNT=2

Results

• Processed 5,000+ files per day
• Reduced upload processing time by 80%
• Improved system reliability with automatic retries
• Scalable solution for growing user base

Analytics Platform

Challenge

An analytics platform needed to process large datasets, generate reports, and send scheduled notifications without impacting real-time data collection.

Solution

# Analytics processing jobs
class DataProcessingJob
  def perform(dataset_id)
    dataset = Dataset.find(dataset_id)
    
    # Process data
    results = AnalyticsService.process(dataset)
    
    # Store results
    dataset.update(results: results, status: 'completed')
    
    # Schedule report generation
    ReportGenerationJob.perform_later(dataset.id)
  end
end

class ReportGenerationJob
  def perform(dataset_id)
    dataset = Dataset.find(dataset_id)
    report = ReportService.generate(dataset)
    
    # Send report
    ReportMailer.send_report(dataset.user, report).deliver_now
  end
end

# Scheduled jobs
class ScheduledReportJob
  def perform
    # Generate weekly reports
    User.find_each do |user|
      WeeklyReportJob.perform_later(user.id)
    end
    
    # Schedule next run
    Delayed::Job.enqueue(self.class.new, run_at: 1.week.from_now)
  end
end

Results

• Processed 1TB+ of data daily
• Generated 10,000+ reports per week
• 99.9% uptime for real-time analytics
• Automated report delivery system

🏢10. Reference & Commands

Configuration Options

Global Configuration

# config/initializers/delayed_job.rb
Delayed::Job.destroy_failed_jobs = false
Delayed::Job.max_attempts = 3
Delayed::Job.max_run_time = 5.minutes
Delayed::Job.sleep_delay = 5
Delayed::Job.read_ahead = 5
Delayed::Job.logger = Rails.logger

Environment Variables

# .env
QUEUE=default,high,low
COUNT=3
RAILS_ENV=production
DATABASE_URL=postgresql://localhost/app_production

Rake Commands

Worker Management

# Start workers
bundle exec rake jobs:work
bundle exec rake jobs:work QUEUE=high,default
bundle exec rake jobs:work QUEUE=* COUNT=4

# Stop workers
pkill -f "delayed_job"

# Restart workers
pkill -f "delayed_job" && bundle exec rake jobs:work

Database Commands

# Generate migration
rails generate delayed_job:install

# Run migration
rails db:migrate

# Check migration status
rails db:migrate:status

Database Schema

Delayed Jobs Table

create_table :delayed_jobs, force: true do |t|
  t.integer  :priority, default: 0, null: false
  t.integer  :attempts, default: 0, null: false
  t.text     :handler,                 null: false
  t.text     :last_error
  t.datetime :run_at
  t.datetime :locked_at
  t.datetime :failed_at
  t.string   :locked_by
  t.string   :queue
  t.datetime :created_at
  t.datetime :updated_at
end

add_index :delayed_jobs, [:priority, :run_at], name: 'delayed_jobs_priority'

Monitoring Queries

Job Statistics

# Overall statistics
Delayed::Job.count
Delayed::Job.where(failed_at: nil).count
Delayed::Job.where.not(failed_at: nil).count

# Queue statistics
Delayed::Job.group(:queue).count
Delayed::Job.group(:priority).count

# Worker statistics
Delayed::Job.where.not(locked_at: nil).group(:locked_by).count
Delayed::Job.where('locked_at < ?', 10.minutes.ago).count

Health Checks

# Check for stuck jobs
Delayed::Job.where('locked_at < ?', 1.hour.ago).count

# Check for old failed jobs
Delayed::Job.where('failed_at < ?', 7.days.ago).count

# Check queue health
Delayed::Job.group(:queue).count.each do |queue, count|
  puts "#{queue}: #{count} jobs"
end

Useful Gems

Core Gems

• delayed_job: Core job processing
• delayed_job_active_record: ActiveRecord backend
• delayed_job_web: Web monitoring interface

Related Gems

• activejob: Rails job abstraction
• sidekiq: Alternative Redis-based solution
• resque: Alternative Redis-based solution
• que: PostgreSQL-based alternative

Resources

Documentation

• Official Documentation: https://github.com/collectiveidea/delayed_job
• Rails Guide: https://guides.rubyonrails.org/active_job_basics.html
• API Documentation: https://www.rubydoc.info/gems/delayed_job

Community

• GitHub Issues: https://github.com/collectiveidea/delayed_job/issues
• Stack Overflow: Search for "delayed_job"
• Rails Forum: https://discuss.rubyonrails.org/

📋11. Commands & Concepts Reference Table

Core Commands

Ruby/Rails Commands

Database Commands

Monitoring Commands

Core Concepts

Configuration Options

Database Schema Fields

Environment Variables

Common Job Patterns