sidekiq-cron 1.12.0 → 2.1.0

data/lib/sidekiq/cron/job.rb

@@ -1,29 +1,109 @@
+# frozen_string_literal: true
+
 require 'fugit'
+require 'cronex'
 require 'globalid'
-require 'sidekiq'
 require 'sidekiq/cron/support'
-require 'sidekiq/options'
 
 module Sidekiq
   module Cron
     class Job
-      # How long we would like to store informations about previous enqueues.
+      # How long we would like to store information about previous enqueues.
       REMEMBER_THRESHOLD = 24 * 60 * 60
 
       # Time format for enqueued jobs.
       LAST_ENQUEUE_TIME_FORMAT = '%Y-%m-%d %H:%M:%S %z'
 
-      # Use the exists? method if we're on a newer version of Redis.
-      REDIS_EXISTS_METHOD = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new("7.0.0") || Gem.loaded_specs['redis'].version < Gem::Version.new('4.2') ? :exists : :exists?
-
       # Use serialize/deserialize key of GlobalID.
       GLOBALID_KEY = "_sc_globalid"
 
+      attr_accessor :name, :namespace, :cron, :description, :klass, :args, :message
+      attr_reader   :last_enqueue_time, :fetch_missing_args, :source
+
+      def initialize input_args = {}
+        args = Hash[input_args.map{ |k, v| [k.to_s, v] }]
+        @fetch_missing_args = args.delete('fetch_missing_args')
+        @fetch_missing_args = true if @fetch_missing_args.nil?
+
+        @name = args["name"]
+        @cron = args["cron"]
+        @description = args["description"] if args["description"]
+        @source = args["source"] == "schedule" ? "schedule" : "dynamic"
+
+        default_namespace = Sidekiq::Cron.configuration.default_namespace
+        @namespace = args["namespace"] || default_namespace
+        if Sidekiq::Cron::Namespace.available_namespaces_provided? && !Sidekiq::Cron::Namespace.all.include?(@namespace) && @namespace != default_namespace
+          Sidekiq.logger.warn { "Cron Jobs - unexpected namespace #{@namespace} encountered. Assigning to default namespace." }
+          @namespace = default_namespace
+        end
+
+        # Get class from klass or class.
+        @klass = args["klass"] || args["class"]
+
+        # Set status of job.
+        @status = args['status'] || status_from_redis
+
+        # Set last enqueue time - from args or from existing job.
+        if args['last_enqueue_time'] && !args['last_enqueue_time'].empty?
+          @last_enqueue_time = parse_enqueue_time(args['last_enqueue_time'])
+        else
+          @last_enqueue_time = last_enqueue_time_from_redis
+        end
+
+        # Get right arguments for job.
+        @symbolize_args = args["symbolize_args"] == true || ("#{args["symbolize_args"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
+        @args = parse_args(args["args"])
+
+        @date_as_argument = args["date_as_argument"] == true || ("#{args["date_as_argument"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
+
+        @active_job = args["active_job"] == true || ("#{args["active_job"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
+        @active_job_queue_name_prefix = args["queue_name_prefix"]
+        @active_job_queue_name_delimiter = args["queue_name_delimiter"]
+
+        # symbolize_args is only used when active_job is true
+        Sidekiq.logger.warn { "Cron Jobs - 'symbolize_args' is gonna be ignored, as it is only used when 'active_job' is true" } if @symbolize_args && !@active_job
+
+        if args["message"]
+          @message = args["message"]
+          message_data = Sidekiq.load_json(@message) || {}
+          @queue = message_data['queue'] || "default"
+          @retry = message_data['retry']
+        elsif @klass
+          message_data = {
+            "class" => @klass.to_s,
+            "args"  => @args,
+          }
+
+          # Get right data for message,
+          # only if message wasn't specified before.
+          klass_data = get_job_options(@klass, @args)
+          message_data = klass_data.merge(message_data)
+
+          # Override queue and retry if set in config,
+          # only if message is hash - can be string (dumped JSON).
+          if args['queue']
+            @queue = message_data['queue'] = args['queue']
+          else
+            @queue = message_data['queue'] || "default"
+          end
+
+          if args['retry'] != nil
+            @retry = message_data['retry'] = args['retry']
+          else
+            @retry = message_data['retry']
+          end
+
+          @message = message_data
+        end
+
+        @queue_name_with_prefix = queue_name_with_prefix
+      end
+
       # Crucial part of whole enqueuing job.
-      def should_enque? time
+      def should_enqueue? time
         return false unless status == "enabled"
-        return false unless not_past_scheduled_time?(time)
-        return false unless not_enqueued_after?(time)
+        return false if past_scheduled_time?(time)
+        return false if enqueued_after?(time)
 
         enqueue = Sidekiq.redis do |conn|
           conn.zadd(job_enqueued_key, formatted_enqueue_time(time), formatted_last_time(time))
@@ -33,23 +113,23 @@ module Sidekiq
 
       # Remove previous information about run times,
       # this will clear Redis and make sure that Redis will not overflow with memory.
-      def remove_previous_enques time
+      def remove_previous_enqueues time
         Sidekiq.redis do |conn|
           conn.zremrangebyscore(job_enqueued_key, 0, "(#{(time.to_f - REMEMBER_THRESHOLD).to_s}")
         end
       end
 
       # Test if job should be enqueued.
-      def test_and_enque_for_time! time
-        if should_enque?(time)
-          enque!
+      def test_and_enqueue_for_time! time
+        if should_enqueue?(time)
+          enqueue!
 
-          remove_previous_enques(time)
+          remove_previous_enqueues(time)
         end
       end
 
       # Enqueue cron job to queue.
-      def enque! time = Time.now.utc
+      def enqueue! time = Time.now.utc
         @last_enqueue_time = time
 
         klass_const =
@@ -80,7 +160,7 @@ module Sidekiq
       end
 
       def is_active_job?(klass = nil)
-        @active_job || defined?(ActiveJob::Base) && (klass || Sidekiq::Cron::Support.constantize(@klass.to_s)) < ActiveJob::Base
+        @active_job || defined?(::ActiveJob::Base) && (klass || Sidekiq::Cron::Support.constantize(@klass.to_s)) < ::ActiveJob::Base
       rescue NameError
         false
       end
@@ -99,7 +179,7 @@ module Sidekiq
       end
 
       def enqueue_sidekiq_worker(klass_const)
-        klass_const.set(queue: queue_name_with_prefix).perform_async(*enqueue_args)
+        klass_const.set(queue: queue_name_with_prefix, retry: @retry).perform_async(*enqueue_args)
       end
 
       # Sidekiq worker message.
@@ -114,16 +194,16 @@ module Sidekiq
 
         if !"#{@active_job_queue_name_delimiter}".empty?
           queue_name_delimiter = @active_job_queue_name_delimiter
-        elsif defined?(ActiveJob::Base) && defined?(ActiveJob::Base.queue_name_delimiter) && !ActiveJob::Base.queue_name_delimiter.empty?
-          queue_name_delimiter = ActiveJob::Base.queue_name_delimiter
+        elsif defined?(::ActiveJob::Base) && defined?(::ActiveJob::Base.queue_name_delimiter) && !::ActiveJob::Base.queue_name_delimiter.empty?
+          queue_name_delimiter = ::ActiveJob::Base.queue_name_delimiter
         else
           queue_name_delimiter = '_'
         end
 
         if !"#{@active_job_queue_name_prefix}".empty?
           queue_name = "#{@active_job_queue_name_prefix}#{queue_name_delimiter}#{@queue}"
-        elsif defined?(ActiveJob::Base) && defined?(ActiveJob::Base.queue_name_prefix) && !"#{ActiveJob::Base.queue_name_prefix}".empty?
-          queue_name = "#{ActiveJob::Base.queue_name_prefix}#{queue_name_delimiter}#{@queue}"
+        elsif defined?(::ActiveJob::Base) && defined?(::ActiveJob::Base.queue_name_prefix) && !"#{::ActiveJob::Base.queue_name_prefix}".empty?
+          queue_name = "#{::ActiveJob::Base.queue_name_prefix}#{queue_name_delimiter}#{@queue}"
         else
           queue_name = @queue
         end
@@ -152,6 +232,7 @@ module Sidekiq
       # Input structure should look like:
       # {
       #   'name_of_job' => {
+      #     'namespace'   => 'MyNamespace',
       #     'class'       => 'MyClass',
       #     'cron'        => '1 * * * *',
       #     'args'        => '(OPTIONAL) [Array or Hash]',
@@ -182,6 +263,7 @@ module Sidekiq
       # Input structure should look like:
       # [
       #   {
+      #     'namespace'   => 'MyNamespace',
       #     'name'        => 'name_of_job',
       #     'class'       => 'MyClass',
       #     'cron'        => '1 * * * *',
@@ -207,19 +289,20 @@ module Sidekiq
       # Like #load_from_array.
       # If exists old jobs in Redis but removed from args, destroy old jobs.
       def self.load_from_array!(array, options = {})
-        job_names = array.map { |job| job["name"] }
+        job_names = array.map { |job| job["name"] || job[:name] }
         destroy_removed_jobs(job_names)
         load_from_array(array, options)
       end
 
       # Get all cron jobs.
-      def self.all
+      def self.all(namespace = Sidekiq::Cron.configuration.default_namespace)
         job_hashes = nil
         Sidekiq.redis do |conn|
-          set_members = conn.smembers(jobs_key)
+          job_keys = job_keys_from_namespace(namespace)
+
           job_hashes = conn.pipelined do |pipeline|
-            set_members.each do |key|
-              pipeline.hgetall(key)
+            job_keys.each do |job_key|
+              pipeline.hgetall(job_key)
             end
           end
         end
@@ -229,22 +312,26 @@ module Sidekiq
         end
       end
 
-      def self.count
-        out = 0
-        Sidekiq.redis do |conn|
-          out = conn.scard(jobs_key)
+      def self.count(namespace = Sidekiq::Cron.configuration.default_namespace)
+        if namespace == '*'
+          Namespace.all_with_count.reduce(0) do |memo, namespace_count|
+            memo + namespace_count[:count]
+          end
+        else
+          Sidekiq.redis { |conn| conn.scard(jobs_key(namespace)) }
         end
-        out
       end
 
-      def self.find name
+      def self.find(name, namespace = Sidekiq::Cron.configuration.default_namespace)
         # If name is hash try to get name from it.
         name = name[:name] || name['name'] if name.is_a?(Hash)
-        return unless exists? name
+        return unless exists? name, namespace
 
         output = nil
         Sidekiq.redis do |conn|
-          output = Job.new conn.hgetall( redis_key(name) )
+          if exists? name, namespace
+            output = Job.new conn.hgetall(redis_key(name, namespace))
+          end
         end
         output if output && output.valid?
       end
@@ -255,93 +342,17 @@ module Sidekiq
       end
 
       # Destroy job by name.
-      def self.destroy name
+      def self.destroy(name, namespace = Sidekiq::Cron.configuration.default_namespace)
         # If name is hash try to get name from it.
         name = name[:name] || name['name'] if name.is_a?(Hash)
 
-        if job = find(name)
+        if (job = find(name, namespace))
           job.destroy
         else
           false
         end
       end
 
-      attr_accessor :name, :cron, :description, :klass, :args, :message
-      attr_reader   :last_enqueue_time, :fetch_missing_args, :source
-
-      def initialize input_args = {}
-        args = Hash[input_args.map{ |k, v| [k.to_s, v] }]
-        @fetch_missing_args = args.delete('fetch_missing_args')
-        @fetch_missing_args = true if @fetch_missing_args.nil?
-
-        @name = args["name"]
-        @cron = args["cron"]
-        @description = args["description"] if args["description"]
-        @source = args["source"] == "schedule" ? "schedule" : "dynamic"
-
-        # Get class from klass or class.
-        @klass = args["klass"] || args["class"]
-
-        # Set status of job.
-        @status = args['status'] || status_from_redis
-
-        # Set last enqueue time - from args or from existing job.
-        if args['last_enqueue_time'] && !args['last_enqueue_time'].empty?
-          @last_enqueue_time = parse_enqueue_time(args['last_enqueue_time'])
-        else
-          @last_enqueue_time = last_enqueue_time_from_redis
-        end
-
-        # Get right arguments for job.
-        @symbolize_args = args["symbolize_args"] == true || ("#{args["symbolize_args"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-        @args = parse_args(args["args"])
-
-        @date_as_argument = args["date_as_argument"] == true || ("#{args["date_as_argument"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-
-        @active_job = args["active_job"] == true || ("#{args["active_job"]}" =~ (/^(true|t|yes|y|1)$/i)) == 0 || false
-        @active_job_queue_name_prefix = args["queue_name_prefix"]
-        @active_job_queue_name_delimiter = args["queue_name_delimiter"]
-
-        if args["message"]
-          @message = args["message"]
-          message_data = Sidekiq.load_json(@message) || {}
-          @queue = message_data['queue'] || "default"
-        elsif @klass
-          message_data = {
-            "class" => @klass.to_s,
-            "args"  => @args,
-          }
-
-          # Get right data for message,
-          # only if message wasn't specified before.
-          klass_data = case @klass
-            when Class
-              @klass.get_sidekiq_options
-            when String
-              begin
-                Sidekiq::Cron::Support.constantize(@klass).get_sidekiq_options
-              rescue Exception => e
-                # Unknown class
-                {"queue"=>"default"}
-              end
-          end
-
-          message_data = klass_data.merge(message_data)
-
-          # Override queue if setted in config,
-          # only if message is hash - can be string (dumped JSON).
-          if args['queue']
-            @queue = message_data['queue'] = args['queue']
-          else
-            @queue = message_data['queue'] || "default"
-          end
-
-          @message = message_data
-        end
-
-        @queue_name_with_prefix = queue_name_with_prefix
-      end
-
       def status
         @status
       end
@@ -370,6 +381,12 @@ module Sidekiq
         message
       end
 
+      def human_cron
+        Cronex::ExpressionDescriptor.new(cron).description
+      rescue => e
+        cron
+      end
+
       def status_from_redis
         out = "enabled"
         if fetch_missing_args
@@ -404,27 +421,24 @@ module Sidekiq
 
       # Export job data to hash.
       def to_hash
-        hash = {
+        {
           name: @name,
+          namespace: @namespace,
           klass: @klass.to_s,
           cron: @cron,
           description: @description,
           source: @source,
           args: @args.is_a?(String) ? @args : Sidekiq.dump_json(@args || []),
+          date_as_argument: date_as_argument? ? "1" : "0",
           message: @message.is_a?(String) ? @message : Sidekiq.dump_json(@message || {}),
           status: @status,
           active_job: @active_job ? "1" : "0",
           queue_name_prefix: @active_job_queue_name_prefix,
           queue_name_delimiter: @active_job_queue_name_delimiter,
+          retry: @retry.nil? || @retry.is_a?(Numeric) ? @retry : @retry.to_s,
           last_enqueue_time: serialized_last_enqueue_time,
           symbolize_args: symbolize_args? ? "1" : "0",
         }
-
-        if date_as_argument?
-          hash.merge!(date_as_argument: "1")
-        end
-
-        hash
       end
 
       def errors
@@ -436,11 +450,14 @@ module Sidekiq
         @errors = []
 
         errors << "'name' must be set" if @name.nil? || @name.size == 0
+        errors << "'namespace' must be set" if @namespace.nil? || @namespace.size == 0
+        errors << "'namespace' cannot be '*'" if @namespace == "*"
+
         if @cron.nil? || @cron.size == 0
           errors << "'cron' must be set"
         else
           begin
-            @parsed_cron = Fugit.do_parse_cronish(@cron)
+            @parsed_cron = do_parse_cron(@cron)
           rescue => e
             errors << "'cron' -> #{@cron.inspect} -> #{e.class}: #{e.message}"
           end
@@ -466,19 +483,23 @@ module Sidekiq
         return false unless valid?
 
         Sidekiq.redis do |conn|
-
           # Add to set of all jobs
-          conn.sadd self.class.jobs_key, [redis_key]
+          conn.sadd self.class.jobs_key(@namespace), [redis_key]
 
-          # Add informations for this job!
-          conn.hset redis_key, to_hash.transform_values! { |v| v || "" }
+          # Add information for this job!
+          conn.hset redis_key, to_hash.transform_values! { |v| v || '' }.flatten
 
-          # Add information about last time! - don't enque right after scheduler poller starts!
+          # Add information about last time! - don't enqueue right after scheduler poller starts!
           time = Time.now.utc
-          exists = conn.public_send(REDIS_EXISTS_METHOD, job_enqueued_key)
-          conn.zadd(job_enqueued_key, time.to_f.to_s, formatted_last_time(time).to_s) unless exists == true || exists == 1
+          exists = conn.exists(job_enqueued_key)
+
+          unless exists == true || exists == 1
+            conn.zadd(job_enqueued_key, time.to_f.to_s, formatted_last_time(time).to_s)
+            Sidekiq.logger.info { "Cron Jobs - added job with name #{@name} in the namespace #{@namespace}" }
+          end
         end
-        Sidekiq.logger.info { "Cron Jobs - added job with name: #{@name}" }
+
+        true
       end
 
       def save_last_enqueue_time
@@ -494,7 +515,7 @@ module Sidekiq
           enqueued: @last_enqueue_time
         }
 
-        @history_size ||= (Sidekiq::Options[:cron_history_size] || 10).to_i - 1
+        @history_size ||= Sidekiq::Cron.configuration.cron_history_size.to_i - 1
         Sidekiq.redis do |conn|
           conn.lpush jid_history_key,
                      Sidekiq.dump_json(jid_history)
@@ -506,9 +527,9 @@ module Sidekiq
       def destroy
         Sidekiq.redis do |conn|
           # Delete from set.
-          conn.srem self.class.jobs_key, [redis_key]
+          conn.srem self.class.jobs_key(@namespace), [redis_key]
 
-          # Delete runned timestamps.
+          # Delete ran timestamps.
           conn.del job_enqueued_key
 
           # Delete jid_history.
@@ -518,7 +539,7 @@ module Sidekiq
           conn.del redis_key
         end
 
-        Sidekiq.logger.info { "Cron Jobs - deleted job with name: #{@name}" }
+        Sidekiq.logger.info { "Cron Jobs - deleted job with name #{@name} from namespace #{@namespace}" }
       end
 
       # Remove all job from cron.
@@ -531,9 +552,17 @@ module Sidekiq
 
       # Remove "removed jobs" between current jobs and new jobs
       def self.destroy_removed_jobs new_job_names
-        current_job_names = Sidekiq::Cron::Job.all.filter_map { |j| j.name if j.source == "schedule" }
+        current_jobs = Sidekiq::Cron::Job.all("*").filter_map { |j| j if j.source == "schedule" }
+        current_job_names = current_jobs.map(&:name)
         removed_job_names = current_job_names - new_job_names
-        removed_job_names.each { |j| Sidekiq::Cron::Job.destroy(j) }
+        removed_job_names.each do |j|
+          job_to_destroy = current_jobs.detect { |job| job.name == j }
+
+          Sidekiq::Cron::Job.destroy(
+            job_to_destroy.name,
+            job_to_destroy.namespace
+          )
+        end
         removed_job_names
       end
 
@@ -551,15 +580,16 @@ module Sidekiq
         last_time(now).getutc.iso8601
       end
 
-      def self.exists? name
+      def self.exists?(name, namespace = Sidekiq::Cron.configuration.default_namespace)
         out = Sidekiq.redis do |conn|
-          conn.public_send(REDIS_EXISTS_METHOD, redis_key(name))
+          conn.exists(redis_key(name, namespace))
         end
-        out == true || out == 1
+
+        [true, 1].include?(out)
       end
 
       def exists?
-        self.class.exists? @name
+        self.class.exists? @name, @namespace
       end
 
       def sort_name
@@ -573,11 +603,25 @@ module Sidekiq
       private
 
       def parsed_cron
-        @parsed_cron ||= Fugit.parse_cronish(@cron)
+        @parsed_cron ||= do_parse_cron(@cron)
       end
 
-      def not_enqueued_after?(time)
-        @last_enqueue_time.nil? || @last_enqueue_time.to_i < last_time(time).to_i
+      def do_parse_cron(cron)
+        case Sidekiq::Cron.configuration.natural_cron_parsing_mode
+        when :single
+          Fugit.do_parse_cronish(cron)
+        when :strict
+          Fugit.parse_cron(cron) || # Ex. '11 1 * * 1'
+          Fugit.parse_nat(cron, :multi => :fail) || # Ex. 'every Monday at 01:11'
+          fail(ArgumentError.new("invalid cron string #{cron.inspect}"))
+        else
+          mode = Sidekiq::Cron.configuration.natural_cron_parsing_mode
+          raise ArgumentError, "Unknown natural cron parsing mode: #{mode.inspect}"
+        end
+      end
+
+      def enqueued_after?(time)
+        @last_enqueue_time && @last_enqueue_time.to_i >= last_time(time).to_i
       end
 
       # Try parsing inbound args into an array.
@@ -631,48 +675,83 @@ module Sidekiq
         DateTime.parse(timestamp).to_time.utc
       end
 
-      def not_past_scheduled_time?(current_time)
+      def past_scheduled_time?(current_time)
         last_cron_time = parsed_cron.previous_time(current_time).utc
-        return false if (current_time.to_i - last_cron_time.to_i) > 60
-        true
+        period = Sidekiq::Cron.configuration.reschedule_grace_period
+
+        current_time.to_i - last_cron_time.to_i > period
       end
 
-      # Redis key for set of all cron jobs.
-      def self.jobs_key
-        "cron_jobs"
+      def self.default_if_blank(namespace)
+        if namespace.nil? || namespace == ''
+          Sidekiq::Cron.configuration.default_namespace
+        else
+          namespace
+        end
+      end
+
+      def self.job_keys_from_namespace(namespace = Sidekiq::Cron.configuration.default_namespace)
+        Sidekiq.redis do |conn|
+          if namespace == '*'
+            namespaces = Sidekiq::Cron.configuration.available_namespaces&.map { jobs_key(_1) } || conn.keys(jobs_key(namespace))
+            namespaces.flat_map { |name| conn.smembers(name) }
+          else
+            conn.smembers(jobs_key(namespace))
+          end
+        end
       end
 
-      # Redis key for storing one cron job.
-      def self.redis_key name
-        "cron_job:#{name}"
+      def self.migrate_old_jobs_if_needed!
+        Sidekiq.redis do |conn|
+          old_job_keys = conn.smembers('cron_jobs')
+          old_job_keys.each do |old_job|
+            old_job_hash = conn.hgetall(old_job)
+            old_job_hash[:namespace] = Sidekiq::Cron.configuration.default_namespace
+            create(old_job_hash)
+            conn.srem('cron_jobs', old_job)
+          end
+        end
       end
 
-      # Redis key for storing one cron job.
+      # Redis key for set of all cron jobs
+      def self.jobs_key(namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_jobs:#{default_if_blank(namespace)}"
+      end
+
+      # Redis key for storing one cron job
+      def self.redis_key(name, namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_job:#{default_if_blank(namespace)}:#{name}"
+      end
+
+      # Redis key for storing one cron job
       def redis_key
-        self.class.redis_key @name
+        self.class.redis_key @name, @namespace
       end
 
-      # Redis key for storing one cron job run times (when poller added job to queue)
-      def self.job_enqueued_key name
-        "cron_job:#{name}:enqueued"
+      # Redis key for storing one cron job run times
+      # (when poller added job to queue)
+      def self.job_enqueued_key(name, namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_job:#{default_if_blank(namespace)}:#{name}:enqueued"
       end
 
-      def self.jid_history_key name
-        "cron_job:#{name}:jid_history"
+      def self.jid_history_key(name, namespace = Sidekiq::Cron.configuration.default_namespace)
+        "cron_job:#{default_if_blank(namespace)}:#{name}:jid_history"
       end
 
+      # Redis key for storing one cron job run times
+      # (when poller added job to queue)
       def job_enqueued_key
-        self.class.job_enqueued_key @name
+        self.class.job_enqueued_key @name, @namespace
       end
 
       def jid_history_key
-        self.class.jid_history_key @name
+        self.class.jid_history_key @name, @namespace
       end
 
       def serialized_last_enqueue_time
         @last_enqueue_time&.strftime(LAST_ENQUEUE_TIME_FORMAT)
       end
-      
+
       def convert_to_global_id_hash(argument)
         { GLOBALID_KEY => argument.to_global_id.to_s }
       rescue URI::GID::MissingModelIdError
@@ -719,6 +798,25 @@ module Sidekiq
           argument
         end
       end
+
+      def get_job_options(klass, args)
+        klass = klass.is_a?(Class) ? klass : begin
+          Sidekiq::Cron::Support.constantize(klass)
+        rescue NameError
+          # noop
+        end
+
+        if klass.nil?
+          # Unknown class
+          {"queue"=>"default"}
+        elsif is_active_job?(klass)
+          job = klass.new(args)
+
+          {"queue"=>job.queue_name}
+        else
+          klass.get_sidekiq_options
+        end
+      end
     end
   end
 end