hirefire-resource 0.10.0 → 1.0.0

data/lib/hirefire/macro/bunny.rb

@@ -1,78 +1,78 @@
 # frozen_string_literal: true
 
+require_relative "deprecated/bunny"
+
 module HireFire
   module Macro
     module Bunny
+      extend HireFire::Macro::Deprecated::Bunny
+      extend HireFire::Errors::JobQueueLatencyUnsupported
+      extend HireFire::Utility
       extend self
 
-      # Returns the job quantity for the provided queue(s).
-      #
-      # @example Bunny Macro Usage
-      #
-      #   # all queues using existing RabbitMQ connection.
-      #   HireFire::Macro::Bunny.queue("queue1", "queue2", :connection => connection)
-      #
-      #   # all queues using new RabbitMQ connection.
-      #   HireFire::Macro::Bunny.queue("queue1", "queue2", :amqp_url => url)
-      #
-      #   # all non-durable queues using new RabbitMQ connection.
-      #   HireFire::Macro::Bunny.queue("queue1", "queue2", :amqp_url => url, :durable => false)
+      class ConnectionError < StandardError; end
+
+      # Calculates the total job queue size using Bunny.
       #
-      # @param [Array] queues provide one or more queue names, or none for "all".
-      #   Last argument can pass in a Hash containing :connection => rabbitmq_connection or :amqp => :rabbitmq_url
-      # @return [Integer] the number of jobs in the queue(s).
+      # If an `amqp_url` is not provided, the method attempts to establish a connection using a
+      # hierarchy of environment variables for the RabbitMQ URL. It checks the following environment
+      # variables in order: `AMQP_URL`, `RABBITMQ_URL`, `RABBITMQ_BIGWIG_URL`, `CLOUDAMQP_URL`. If
+      # none of these variables are set, it defaults to a local RabbitMQ instance at
+      # "amqp://guest:guest@localhost:5672".
       #
-      def queue(*queues)
+      # @note It's important to separate jobs scheduled for future execution into a different queue
+      #   from the regular queue. This is because including them in the regular queue can interfere
+      #   with the accurate counting of jobs that are currently scheduled to run, leading to
+      #   premature upscaling. If you want to be able to schedule jobs to run in the future,
+      #   consider using the Delayed Message Plugin for RabbitMQ.
+      # @param queues [Array<String, Symbol>] Names of the queues for size measurement.
+      # @param amqp_url [String, nil] (optional) RabbitMQ URL for establishing a new connection.
+      # @return [Integer] Total job queue size.
+      # @raise [HireFire::Errors::MissingQueueError] If no queue names are specified.
+      # @example Retrieve job queue size for the "default" queue
+      #   HireFire::Macro::Bunny.job_queue_size(:default)
+      # @example Retrieve job queue size across "default" and "mailer" queues
+      #   HireFire::Macro::Bunny.job_queue_size(:default, :mailer)
+      # @example Use a new connection on each call using a AMQP URL
+      #   HireFire::Macro::Bunny.job_queue_size(:default, amqp_url: url)
+      def job_queue_size(*queues, amqp_url: nil)
         require "bunny"
 
-        queues.flatten!
+        queues = normalize_queues(queues, allow_empty: false)
+        channel, connection = setup_channel(amqp_url)
 
-        options = if queues.last.is_a?(Hash)
-          queues.pop
-        else
-          {}
+        begin
+          queues.sum { |name| channel.queue(name, passive: true).message_count }
+        ensure
+          channel&.close
+          connection&.close
         end
+      end
 
-        if options[:durable].nil?
-          options[:durable] = true
-        end
+      private
 
-        if options[:connection]
-          connection = options[:connection]
+      def setup_channel(amqp_url)
+        connection = acquire_connection(amqp_url)
 
-          channel = nil
-          begin
-            channel = connection.create_channel
-            count_messages(channel, queues, options)
-          ensure
-            channel&.close
-          end
-        elsif options[:amqp_url]
-          connection = ::Bunny.new(options[:amqp_url])
-          begin
-            connection.start
-            channel = connection.create_channel
-            count_messages(channel, queues, options)
-          ensure
-            channel&.close
-            connection.close
-          end
+        if connection
+          [connection.create_channel, connection]
         else
-          raise %(Must pass in :connection => rabbitmq_connection or :amqp_url => url\n) +
-            %{For example: HireFire::Macro::Bunny.queue("queue1", :connection => rabbitmq_connection}
+          raise ConnectionError, <<~ERROR_MSG
+            Unable to establish connection with RabbitMQ.
+            Ensure that a valid AMQP URL is provided.
+          ERROR_MSG
         end
       end
 
-      def count_messages(channel, queue_names, options)
-        queue_names.inject(0) do |sum, queue_name|
-          queue = if options.key?(:'x-max-priority')
-            channel.queue(queue_name, durable: options[:durable],
-                                              arguments: {"x-max-priority" => options[:'x-max-priority']})
-          else
-            channel.queue(queue_name, durable: options[:durable])
-          end
-          sum + queue.message_count
-        end
+      def acquire_connection(amqp_url)
+        url = amqp_url ||
+          ENV["AMQP_URL"] ||
+          ENV["RABBITMQ_URL"] ||
+          ENV["RABBITMQ_BIGWIG_URL"] ||
+          ENV["CLOUDAMQP_URL"] ||
+          "amqp://guest:guest@localhost:5672"
+
+        ::Bunny.new(url).tap(&:start)
       end
     end
   end

data/lib/hirefire/macro/delayed_job.rb

@@ -1,78 +1,98 @@
 # frozen_string_literal: true
 
+require_relative "deprecated/delayed_job"
+
 module HireFire
   module Macro
     module Delayed
       module Job
+        extend HireFire::Macro::Deprecated::Delayed::Job
+        extend HireFire::Utility
         extend self
 
-        # Returns the job quantity for the provided queue(s).
-        #
-        # @example Delayed::Job Macro Usage
-        #
-        #   # all queues using ActiveRecord mapper.
-        #   HireFire::Macro::Delayed::Job.queue(:mapper => :active_record)
-        #
-        #   # all queues using ActiveRecord <= 2.3.x mapper.
-        #   HireFire::Macro::Delayed::Job.queue(:mapper => :active_record_2)
-        #
-        #   # only "email" queue with Mongoid mapper.
-        #   HireFire::Macro::Delayed::Job.queue("email", :mapper => :mongoid)
-        #
-        #   # "audio" and "video" queues with ActiveRecord mapper.
-        #   HireFire::Macro::Delayed::Job.queue("audio", "video", :mapper => :active_record)
-        #
-        #   # all queues with a maximum priority of 20
-        #   HireFire::Macro::Delayed::Job.queue(:max_priority => 20, :mapper => :active_record)
-        #
-        #   # all queues with a minimum priority of 5
-        #   HireFire::Macro::Delayed::Job.queue(:min_priority => 5, :mapper => :active_record)
-        #
-        # @param [Array] queues provide one or more queue names, or none for "all".
-        #   Last argument can pass in a Hash containing :mapper => :active_record or :mapper => :mongoid
-        # @return [Integer] the number of jobs in the queue(s).
+        class MapperNotDetectedError < StandardError; end
+
+        # Calculates the maximum job queue latency using Delayed::Job. If no queues are specified,
+        # it measures latency across all available queues. This method supports both ActiveRecord
+        # and Mongoid mappers.
         #
-        def queue(*queues)
-          queues.flatten!
+        # @param queues [Array<String, Symbol>] (optional) Names of the queues for latency
+        #   measurement. If not provided, latency is measured across all queues.
+        # @return [Float] Maximum job queue latency in seconds.
+        # @example Calculate latency across all queues
+        #   HireFire::Macro::Delayed::Job.job_queue_latency
+        # @example Calculate latency for the "default" queue
+        #   HireFire::Macro::Delayed::Job.job_queue_latency(:default)
+        # @example Calculate latency across "default" and "mailer" queues
+        #   HireFire::Macro::Delayed::Job.job_queue_latency(:default, :mailer)
+        def job_queue_latency(*queues)
+          queues = normalize_queues(queues, allow_empty: true)
 
-          options = if queues.last.is_a?(Hash)
-            queues.pop
+          query =
+            ::Delayed::Job
+              .where(run_at: ..Time.now)
+              .where(failed_at: nil)
+              .order(run_at: :asc)
+
+          if queues.any?
+            case mapper
+            when :active_record
+              query = query.where(queue: queues)
+            when :mongoid
+              query = query.in(queue: queues.to_a)
+            end
+          end
+
+          if (job = query.first)
+            Time.now - job.run_at
           else
-            {}
+            0.0
           end
+        end
+
+        # Calculates the total job queue size using Delayed::Job. If no queues are specified, it
+        # measures size across all available queues. This method supports both ActiveRecord and
+        # Mongoid mappers.
+        #
+        # @param queues [Array<String, Symbol>] (optional) Names of the queues for size measurement.
+        #   If not provided, size is measured across all queues.
+        # @return [Integer] Total job queue size.
+        # @example Calculate size across all queues
+        #   HireFire::Macro::Delayed::Job.job_queue_size
+        # @example Calculate size of the "default" queue
+        #   HireFire::Macro::Delayed::Job.job_queue_size(:default)
+        # @example Calculate size across "default" and "mailer" queues
+        #   HireFire::Macro::Delayed::Job.job_queue_size(:default, :mailer)
+        def job_queue_size(*queues)
+          queues = normalize_queues(queues, allow_empty: true)
+
+          query =
+            ::Delayed::Job
+              .where(run_at: ..Time.now)
+              .where(failed_at: nil)
 
-          case options[:mapper]
-          when :active_record
-            c = ::Delayed::Job
-            c = c.where(failed_at: nil)
-            c = c.where("run_at <= ?", Time.now.utc)
-            c = c.where("priority >= ?", options[:min_priority]) if options.key?(:min_priority)
-            c = c.where("priority <= ?", options[:max_priority]) if options.key?(:max_priority)
-            c = c.where(queue: queues) unless queues.empty?
-            c.count.tap { ActiveRecord::Base.clear_active_connections! }
-          when :active_record_2
-            c = ::Delayed::Job
-            c = c.scoped(conditions: ["run_at <= ? AND failed_at is NULL", Time.now.utc])
-            c = c.scoped(conditions: ["priority >= ?", options[:min_priority]]) if options.key?(:min_priority)
-            c = c.scoped(conditions: ["priority <= ?", options[:max_priority]]) if options.key?(:max_priority)
-            # There is no queue column in delayed_job <= 2.x
-            c.count.tap do
-              if ActiveRecord::Base.respond_to?(:clear_active_connections!)
-                ActiveRecord::Base.clear_active_connections!
-              end
+          if queues.any?
+            case mapper
+            when :active_record
+              query = query.where(queue: queues)
+            when :mongoid
+              query = query.in(queue: queues.to_a)
             end
-          when :mongoid
-            c = ::Delayed::Job
-            c = c.where(failed_at: nil)
-            c = c.where(:run_at.lte => Time.now.utc)
-            c = c.where(:priority.gte => options[:min_priority]) if options.key?(:min_priority)
-            c = c.where(:priority.lte => options[:max_priority]) if options.key?(:max_priority)
-            c = c.where(:queue.in => queues) unless queues.empty?
-            c.count
-          else
-            raise %(Must pass in :mapper => :active_record or :mapper => :mongoid\n) +
-              %{For example: HireFire::Macro::Delayed::Job.queue("worker", :mapper => :active_record)}
           end
+
+          query.count
+        end
+
+        private
+
+        def mapper
+          return :active_record if defined?(::ActiveRecord::Base) &&
+            ::Delayed::Job.ancestors.include?(::ActiveRecord::Base)
+
+          return :mongoid if defined?(::Mongoid::Document) &&
+            ::Delayed::Job.ancestors.include?(::Mongoid::Document)
+
+          raise MapperNotDetectedError, "Unable to detect the appropriate mapper."
         end
       end
     end

data/lib/hirefire/macro/deprecated/bunny.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module HireFire
+  module Macro
+    module Deprecated
+      # Provides backward compatibility with the deprecated Bunny macro.
+      # For new implementations, refer to {HireFire::Macro::Bunny}.
+      module Bunny
+        # Retrieves the total number of jobs in the specified queue(s).
+        #
+        # This method allows querying multiple queues and supports both existing and new RabbitMQ
+        # connections. By default, queues are considered durable unless specified otherwise.
+        #
+        # @param queues [Array<String, Symbol>] Queue names to query.
+        #   The last argument can be a Hash with either :connection or :amqp_url.
+        # @option queues [Bunny::Session, nil] :connection An existing RabbitMQ connection.
+        # @option queues [String, nil] :amqp_url RabbitMQ URL for initializing a new connection.
+        # @option queues [Boolean] :durable (true) Set to false for non-durable queues.
+        # @option queues [Integer, nil] :"x-max-priority" (nil) The maximum priority level for the queue.
+        #   If specified, it overrides the default priority settings for the queue.
+        # @return [Integer] Total number of jobs in the specified queues.
+        # @raise [ArgumentError] Raises an error if neither :connection nor :amqp_url are provided.
+        # @example Querying the default queue using an existing RabbitMQ connection
+        #   HireFire::Macro::Bunny.queue("default", connection: connection)
+        # @example Querying the default queue using a new RabbitMQ connection
+        #   HireFire::Macro::Bunny.queue("default", amqp_url: url)
+        # @example Querying the "default" and "critical" non-durable queues
+        #   HireFire::Macro::Bunny.queue("default", "critical", amqp_url: url, durable: false)
+        # @example Querying a priority queue
+        #   HireFire::Macro::Bunny.queue("priority_queue", connection: connection, "x-max-priority": 10)
+        def queue(*queues)
+          require "bunny"
+
+          queues.flatten!
+          options = queues.last.is_a?(Hash) ? queues.pop : {}
+          options[:durable] = true if options[:durable].nil?
+
+          if options[:connection]
+            connection = options[:connection]
+            channel = nil
+            begin
+              channel = connection.create_channel
+              Private.count_messages(channel, queues, options)
+            ensure
+              channel&.close
+            end
+          elsif options[:amqp_url]
+            connection = ::Bunny.new(options[:amqp_url])
+            begin
+              connection.start
+              channel = connection.create_channel
+              Private.count_messages(channel, queues, options)
+            ensure
+              channel&.close
+              connection.close
+            end
+          else
+            raise ArgumentError, "Must pass either :connection => rabbitmq_connection or :amqp_url => url." \
+                                 "For example: HireFire::Macro::Bunny.queue(\"queue1\", connection: rabbitmq_connection)"
+          end
+        end
+
+        # @!visibility private
+        module Private
+          extend self
+
+          # Counts the number of messages in the specified queues.
+          #
+          # @param channel [Bunny::Channel] The channel to interact with RabbitMQ.
+          # @param queues [Array<String, Symbol>] The names of the queues to count messages from.
+          # @param options [Hash] The options for the queues, including durability and priority settings.
+          # @return [Integer] The total number of messages across all specified queues.
+          def count_messages(channel, queues, options)
+            queues.inject(0) do |sum, queue|
+              queue_options = {durable: options[:durable]}
+              queue_options[:arguments] = {"x-max-priority" => options[:"x-max-priority"]} if options.key?(:"x-max-priority")
+              queue = channel.queue(queue.to_s, **queue_options)
+              sum + queue.message_count
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hirefire/macro/deprecated/delayed_job.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module HireFire
+  module Macro
+    module Deprecated
+      module Delayed
+        # Provides backward compatibility with the deprecated Delayed::Job macro.
+        # For new implementations, refer to {HireFire::Macro::Delayed::Job}.
+        module Job
+          # 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.
+          #
+          # @param queues [Array<String, Symbol>] Queue names to query.
+          #   The last argument can be a Hash with :mapper, :min_priority, and/or :max_priority keys.
+          # @option queues [Symbol] :mapper (:active_record, :active_record_2, :mongoid) The ORM mapper to use.
+          # @option queues [Integer, nil] :min_priority (nil) The minimum job priority to include in the count.
+          #   If not specified, no lower limit is applied.
+          # @option queues [Integer, nil] :max_priority (nil) The maximum job priority to include in the count.
+          #   If not specified, no upper limit is applied.
+          # @return [Integer] Total number of jobs in the specified queues.
+          # @raise [ArgumentError] Raises an error if a valid :mapper option is not provided.
+          # @example Querying all queues using ActiveRecord mapper
+          #   HireFire::Macro::Delayed::Job.queue(mapper: :active_record)
+          # @example Querying specific queues with Mongoid mapper
+          #   HireFire::Macro::Delayed::Job.queue("default", mapper: :mongoid)
+          # @example Query all queues scoped to a priority range
+          #   HireFire::Macro::Delayed::Job.queue(max_priority: 20, min_priority: 5, mapper: :active_record)
+          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.tap { ActiveRecord::Base.clear_active_connections! }
+            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.tap { ActiveRecord::Base.clear_active_connections! if ActiveRecord::Base.respond_to?(:clear_active_connections!) }
+            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
+        end
+      end
+    end
+  end
+end

data/lib/hirefire/macro/deprecated/good_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module HireFire
+  module Macro
+    module Deprecated
+      # Provides backward compatibility with the deprecated GoodJob macro.
+      # For new implementations, refer to {HireFire::Macro::GoodJob}.
+      module GoodJob
+        # Retrieves the total number of jobs in the specified queue(s) using GoodJob.
+        #
+        # This method queries the PostgreSQL database through GoodJob. It's capable
+        # of counting jobs across different queues or all queues if none specified.
+        # The method checks for the existence of ::GoodJob::Execution or ::GoodJob::Job
+        # to determine the base class to use for querying.
+        #
+        # @param queues [Array<String>] The names of the queues to count.
+        #   Pass an empty array or no arguments to count jobs in all queues.
+        # @return [Integer] Total number of jobs in the specified queues.
+        # @example Counting jobs in all queues
+        #   HireFire::Macro::GoodJob.queue
+        # @example Counting jobs in the "default" queue
+        #   HireFire::Macro::GoodJob.queue("default")
+        def queue(*queues)
+          base_class = defined?(::GoodJob::Execution) ? ::GoodJob::Execution : ::GoodJob::Job
+          scope = base_class.only_scheduled.unfinished
+          scope = scope.where(queue_name: queues) if queues.any?
+          scope.count
+        end
+      end
+    end
+  end
+end

data/lib/hirefire/macro/deprecated/que.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module HireFire
+  module Macro
+    module Deprecated
+      # Provides backward compatibility with the deprecated Que macro.
+      # For new implementations, refer to {HireFire::Macro::Que}.
+      module Que
+        # Retrieves the total number of jobs in the specified queue(s) using Que.
+        #
+        # This method queries the PostgreSQL database through Que. It can count jobs
+        # in specified queues or all queues if no specific queue is provided.
+        # The method determines the base query depending on the Que version detected.
+        #
+        # @param queues [Array<String>] The names of the queues to count.
+        #   Pass an empty array or no arguments to count jobs in all queues.
+        # @return [Integer] Total number of jobs in the specified queues.
+        # @example Counting jobs in all queues
+        #   HireFire::Macro::Que.queue
+        # @example Counting jobs in the "default" queue
+        #   HireFire::Macro::Que.queue("default")
+        def queue(*queues)
+          query = queues.empty? ? Private.base_query : "#{Private.base_query} AND queue IN (#{Private.names(queues)})"
+          results = ::Que.execute(query).first
+          (results[:total] || results["total"]).to_i
+        end
+
+        # @!visibility private
+        module Private
+          extend self
+
+          # Determines the base query to use for counting jobs, depending on the Que version.
+          #
+          # @return [String] The base SQL query string.
+          def base_query
+            return QUE_V0_QUERY if defined?(::Que::Version)
+            return QUE_V1_QUERY if defined?(::Que::VERSION)
+            raise "Couldn't find Que version"
+          end
+
+          # Formats queue names for SQL query.
+          #
+          # @param queues [Array<String>] The names of the queues.
+          # @return [String] Formatted queue names for SQL IN clause.
+          def names(queues)
+            queues.map { |queue| "'#{queue}'" }.join(",")
+          end
+
+          # Formats and freezes a SQL query string for use.
+          #
+          # @param query [String] The raw SQL query string.
+          # @return [String] The formatted and frozen SQL query string.
+          def query_const(query)
+            query.gsub(/\s+/, " ").strip.freeze
+          end
+
+          # SQL query string for Que version 0.
+          QUE_V0_QUERY = query_const(<<-QUERY)
+            SELECT COUNT(*) AS total
+            FROM que_jobs
+            WHERE run_at < NOW()
+          QUERY
+
+          # SQL query string for Que version 1.
+          QUE_V1_QUERY = query_const(<<-QUERY)
+            SELECT COUNT(*) AS total
+            FROM que_jobs
+            WHERE finished_at IS NULL
+            AND expired_at IS NULL
+            AND run_at <= NOW()
+          QUERY
+        end
+      end
+    end
+  end
+end

data/lib/hirefire/macro/deprecated/queue_classic.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module HireFire
+  module Macro
+    module Deprecated
+      # Provides backward compatibility with the deprecated QC macro.
+      # For new implementations, refer to {HireFire::Macro::QC}.
+      module QC
+        # Retrieves the total number of jobs in the specified queue using QueueClassic.
+        #
+        # This method queries the PostgreSQL database through QueueClassic. It's capable of counting
+        # jobs in a specific queue, defaulting to the "default" queue if none is specified.
+        # It utilizes the QC::Queue class to interface with the QueueClassic system.
+        #
+        # @param queue [String, Symbol] The name of the queue to count.
+        #   Defaults to "default" if no queue name is provided.
+        # @return [Integer] Total number of jobs in the specified queue.
+        # @example Counting jobs in the "default" queue
+        #   HireFire::Macro::QC.queue
+        # @example Counting jobs in the "critical" queue
+        #   HireFire::Macro::QC.queue("critical")
+        def queue(queue = "default")
+          ::QC::Queue.new(queue.to_s).count
+        end
+      end
+    end
+  end
+end

data/lib/hirefire/macro/deprecated/resque.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module HireFire
+  module Macro
+    module Deprecated
+      # Provides backward compatibility with the deprecated Resque macro.
+      # For new implementations, refer to {HireFire::Macro::Resque}.
+      module Resque
+        # Retrieves the total number of jobs in the specified Resque queue(s).
+        #
+        # This method counts the number of jobs in either specific queues or all queues if none are
+        # specified. It includes both queued and in-progress jobs.
+        #
+        # @param queues [Array<String, Symbol>] Queue names to count jobs in.
+        #   Pass an empty array or no arguments to count jobs in all queues.
+        # @return [Integer] Total number of jobs in the specified queues.
+        # @example Counting jobs in all queues
+        #   HireFire::Macro::Resque.queue
+        # @example Counting jobs in the "default" queue
+        #   HireFire::Macro::Resque.queue("default")
+        # @example Counting jobs in both "default" and "critical" queues
+        #   HireFire::Macro::Resque.queue("default", "critical")
+        def queue(*queues)
+          queues = queues.flatten.map(&:to_s)
+          queues = ::Resque.queues if queues.empty?
+
+          return 0 if queues.empty?
+
+          redis = ::Resque.redis
+          worker_ids = Array(redis.smembers(:workers)).compact
+          raw_jobs = redis.pipelined do |redis|
+            worker_ids.map { |id| redis.get("worker:#{id}") }
+          end
+          jobs_in_progress = raw_jobs.map { |raw_job| ::Resque.decode(raw_job) || {} }
+
+          jobs_in_queues = redis.pipelined do |redis|
+            queues.map { |queue| redis.llen("queue:#{queue}") }
+          end.map(&:to_i).sum
+
+          in_progress_count = jobs_in_progress.count { |job| queues.include?(job["queue"]) }
+
+          jobs_in_queues + in_progress_count
+        end
+      end
+    end
+  end
+end