Module: HireFire::Macro::Deprecated::Delayed::Job

Included in:
HireFire::Macro::Delayed::Job
Defined in:
lib/hirefire/macro/deprecated/delayed_job.rb

Overview

Provides backward compatibility with the deprecated Delayed::Job macro. For new implementations, refer to HireFire::Macro::Delayed::Job.

Instance Method Summary collapse

Instance Method Details

#queue(*queues) ⇒ Integer

Retrieves the total number of jobs in the specified queue(s).

This method supports querying jobs across different ORMs (Object-Relational Mappings) such as ActiveRecord and Mongoid. It allows specifying queue names and priority limits.

Examples:

Querying all queues using ActiveRecord mapper

HireFire::Macro::Delayed::Job.queue(mapper: :active_record)

Querying specific queues with Mongoid mapper

HireFire::Macro::Delayed::Job.queue("default", mapper: :mongoid)

Query all queues scoped to a priority range

HireFire::Macro::Delayed::Job.queue(max_priority: 20, min_priority: 5, mapper: :active_record)

Parameters:

  • queues (Array<String, Symbol>) —

    Queue names to query. The last argument can be a Hash with :mapper, :min_priority, and/or :max_priority keys.

Options Hash (*queues):

  • :mapper (Symbol) — default: :active_record, :active_record_2, :mongoid —

    The ORM mapper to use.

  • :min_priority (Integer, nil) — default: nil —

    The minimum job priority to include in the count. If not specified, no lower limit is applied.

  • :max_priority (Integer, nil) — default: nil —

    The maximum job priority to include in the count. If not specified, no upper limit is applied.

Returns:

  • (Integer) —

    Total number of jobs in the specified queues.

Raises:

  • (ArgumentError) —

    Raises an error if a valid :mapper option is not provided.



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/hirefire/macro/deprecated/delayed_job.rb', line 30

def queue(*queues)
  queues.flatten!
  options = queues.last.is_a?(Hash) ? queues.pop : {}

  case options[:mapper]
  when :active_record
    query = ::Delayed::Job.where(failed_at: nil, run_at: ..Time.now.utc)
    query = query.where(priority: options[:min_priority]..) if options.key?(:min_priority)
    query = query.where(priority: ..options[:max_priority]) if options.key?(:max_priority)
    query = query.where(queue: queues) unless queues.empty?
    query.count
  when :active_record_2
    # Note: There is no queue column in delayed_job <= 2.x
    query = ::Delayed::Job.scoped(conditions: ["run_at <= ? AND failed_at is NULL", Time.now.utc])
    query = query.scoped(conditions: ["priority >= ?", options[:min_priority]]) if options.key?(:min_priority)
    query = query.scoped(conditions: ["priority <= ?", options[:max_priority]]) if options.key?(:max_priority)
    query.count
  when :mongoid
    query = ::Delayed::Job.where(:failed_at => nil, :run_at.lte => Time.now.utc)
    query = query.where(:priority.gte => options[:min_priority]) if options.key?(:min_priority)
    query = query.where(:priority.lte => options[:max_priority]) if options.key?(:max_priority)
    query = query.where(:queue.in => queues) unless queues.empty?
    query.count
  else
    raise ArgumentError, "Must pass either :mapper => :active_record or :mapper => :mongoid. " \
                         "For example: HireFire::Macro::Delayed::Job.queue(\"worker\", mapper: :active_record)"
  end
end