module ActiveJob::Exceptions

def determine_delay(seconds_or_duration_or_algorithm:, executions:)

def determine_delay(seconds_or_duration_or_algorithm:, executions:)
  case seconds_or_duration_or_algorithm
  when :exponentially_longer
    (executions**4) + 2
  when ActiveSupport::Duration
    duration = seconds_or_duration_or_algorithm
    duration.to_i
  when Integer
    seconds = seconds_or_duration_or_algorithm
    seconds
  when Proc
    algorithm = seconds_or_duration_or_algorithm
    algorithm.call(executions)
  else
    raise "Couldn't determine a delay based on #{seconds_or_duration_or_algorithm.inspect}"
  end
end

def executions_for(exceptions)

def executions_for(exceptions)
  if exception_executions
    exception_executions[exceptions.to_s] = (exception_executions[exceptions.to_s] || 0) + 1
  else
    # Guard against jobs that were persisted before we started having individual executions counters per retry_on
    executions
  end
end

def instrument(name, error: nil, wait: nil, &block)

def instrument(name, error: nil, wait: nil, &block)
  payload = { job: self, adapter: self.class.queue_adapter, error: error, wait: wait }
  ActiveSupport::Notifications.instrument("#{name}.active_job", payload, &block)
end

def retry_job(options = {})

end
end
# raise ErrorLoadingSite if cannot scrape
def perform(*args)

end
retry_job queue: :low_priority
rescue_from(ErrorLoadingSite) do
class SiteScraperJob < ActiveJob::Base

==== Examples

* :priority - Enqueues the job with the specified priority
* :queue - Enqueues the job on the specified queue
* :wait_until - Enqueues the job at the time specified
* :wait - Enqueues the job with the specified delay in seconds
==== Options

you can ask Active Job to retry performing your job.
with the +rescue_from+ option. When you rescue an exception from your job
Reschedules the job to be re-executed. This is useful in combination

def retry_job(options = {})
  instrument :enqueue_retry, options.slice(:error, :wait) do
    enqueue options
  end
end

Modules

Classes