# Good: Pass identifiers
class ProcessOrderJob < ApplicationJob
  def perform(order_id)
    order = Order.find(order_id)
    # Process order
  end
end

3. Queue Configuration

class CriticalNotificationJob < ApplicationJob
  queue_as :critical
  queue_with_priority 1  # Lower = higher priority
end

class ReportGenerationJob < ApplicationJob
  queue_as :low_priority
  queue_with_priority 50
end

Error Handling & Retry Strategies

class ExternalApiJob < ApplicationJob
  queue_as :default

  retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 5
  retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
  discard_on ActiveJob::DeserializationError

  def perform(record_id)
    record = Record.find(record_id)
    ExternalApi.sync(record)
  end
end

Custom Error Handling

class ImportantJob < ApplicationJob
  rescue_from StandardError do |exception|
    Rails.logger.error("Job failed: #{exception.message}")
    ErrorNotifier.notify(exception, job: self.class.name)
    raise # Re-raise to trigger retry
  end
end

Concurrency Control (Solid Queue)

class ProcessUserDataJob < ApplicationJob
  limits_concurrency key: ->(user_id) { user_id }, duration: 15.minutes

  def perform(user_id)
    user = User.find(user_id)
    # Process user data safely
  end
end

class ContactActionJob < ApplicationJob
  limits_concurrency key: ->(contact) { contact.id },
                     duration: 10.minutes,
                     group: "ContactActions"
end

Scheduling & Delayed Execution

SendReminderJob.perform_later(user)                              # Immediate
SendReminderJob.set(wait: 1.hour).perform_later(user)            # Delayed
SendReminderJob.set(wait_until: Date.tomorrow.noon).perform_later(user)  # Scheduled

# Bulk enqueue
ActiveJob.perform_all_later(users.map { |u| SendReminderJob.new(u.id) })

Anti-Patterns to Avoid

Anti-Pattern	Problem	Solution
Fat jobs	Hard to test and maintain	Extract logic to model classes
Serializing objects	Expensive, stale data	Pass IDs, fetch fresh data
No retry strategy	Silent failures	Use `retry_on` with backoff
Synchronous calls	Blocks request	Always use `perform_later`
No idempotency	Duplicate processing	Design jobs to be re-runnable
Ignoring errors	Silent failures	Use `rescue_from` with logging
Monolithic steps	Can't resume after failure	Use Continuable pattern with state

Output Format

When creating or refactoring jobs, provide:

Job Class - The complete job implementation
Queue Strategy - Recommended queue and priority
Error Handling - Retry and failure strategies
Testing - Example test cases
Considerations - Concurrency, idempotency notes

active-job-coder

Active Job Coder

Job Design Principles

1. Single Responsibility

2. Pass IDs, Not Objects