sidekiq-scheduler 2.1.10 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a3f7cb5ee802d2e3b5c89b308fbcaff612911217
-  data.tar.gz: e6b488b10334b3af01c9d2521e31ec3c53f0ef20
+SHA256:
+  metadata.gz: 7c9e10cdd3a2bfc144f07860038c95ef459bb2bf8800d763ea90379b6c709472
+  data.tar.gz: 8f4be75200f8a5c44f53227ba73586e5e6ac9e8885972163382b372372086af0
 SHA512:
-  metadata.gz: b56413d0c141f2ae15bfacb255a8eed2550b6b0f899703f5fd08d67539794878e411d9a5a48086f4fd9d7f542f6b78fe9a016b7edf32a78819b93c7860ecf2a2
-  data.tar.gz: 6b8524661830f24e9233a95ec94a18ad31eac1f0880a63a3bc48f728e802f8f5ffe79437bfd5d17bdc3ec07a79d142b0d991b33a5a6363f79a4e6f1c387ee2c2
+  metadata.gz: e8dc47d6600676d0de6cac9b508026315c2eefcf6a055b496abd84ed663ec9bb9eddc267246ba877588ec4abb67d79a773664238d1028e23ca2859869e76dedd
+  data.tar.gz: 78764a88d67d2c501a4df10a8d7b79331146912a4d5fa2c83a04e1b06165bd45ceec0a11232e8e841fc452d6fd79e985142ad72a945e4fc04a8d79aa7090f79c

data/README.md

@@ -30,6 +30,8 @@
 `sidekiq-scheduler` is an extension to [Sidekiq](http://github.com/mperham/sidekiq) that
 pushes jobs in a scheduled way, mimicking cron utility.
 
+__Note:__ If you are looking for version 2.2.*, go to [2.2-stable branch](https://github.com/moove-it/sidekiq-scheduler/tree/2.2-stable).
+
 ## Installation
 
 ``` shell
@@ -180,6 +182,8 @@ Cron, every, and interval types push jobs into sidekiq in a recurrent manner.
 `interval` is similar to `every`, the difference between them is that `interval` type schedules the
 next execution after the interval has elapsed counting from its last job enqueue.
 
+Note that `every` and `interval` count from when the Sidekiq process (re)starts. So `every: '48h'` will never run if the Sidekiq process is restarted daily, for example. You can do `every: ['48h', first_in: '0s']` to make the job run immediately after a restart, and then have the worker check when it was last run.
+
 At, and in types push jobs only once. `at` schedules in a point in time:
 ``` yaml
     at: '3001/01/01'
@@ -223,12 +227,12 @@ To load the schedule:
 
 ``` ruby
 require 'sidekiq'
-require 'sidekiq/scheduler'
+require 'sidekiq-scheduler'
 
 Sidekiq.configure_server do |config|
   config.on(:startup) do
     Sidekiq.schedule = YAML.load_file(File.expand_path('../../sidekiq_scheduler.yml', __FILE__))
-    Sidekiq::Scheduler.reload_schedule!
+    SidekiqScheduler::Scheduler.instance.reload_schedule!
   end
 end
 ```
@@ -256,7 +260,7 @@ If `:dynamic` flag is set to `false`, you'll have to reload the schedule manuall
 side:
 
 ``` ruby
-Sidekiq::Scheduler.reload_schedule!
+SidekiqScheduler::Scheduler.instance.reload_schedule!
 ```
 
 Invoke `Sidekiq.get_schedule` to obtain the current schedule:
@@ -268,8 +272,9 @@ Sidekiq.get_schedule
 
 ## Time zones
 
-Note that if you use the cron syntax, this will be interpreted as in the server time zone
-rather than the `config.time_zone` specified in Rails.
+Note that if you use the cron syntax and are not running a Rails app, this will be interpreted in the server time zone.
+
+In a Rails app, [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) (>= 3.3.3) will use the `config.time_zone` specified in Rails.
 
 You can explicitly specify the time zone that rufus-scheduler will use:
 
@@ -285,11 +290,27 @@ from the `config.time_zone` value, make sure it's the right format, e.g. with:
 ActiveSupport::TimeZone.find_tzinfo(Rails.configuration.time_zone).name
 ```
 
+## Notes about connection pooling
+
+If you're configuring your own Redis connection pool, you need to make sure the size is adequate to be inclusive of both Sidekiq's own connection pool and Rufus Scheduler's.
+
+That's a minimum of `concurrency` + 5 (per the [Sidekiq wiki](https://github.com/mperham/sidekiq/wiki/Using-Redis#complete-control)) + `Rufus::Scheduler::MAX_WORK_THREADS` (28 as of this writing; per the [Rufus README](https://github.com/jmettraux/rufus-scheduler#max_work_threads)), for a total of 58 with the default `concurrency` of 25.
+
+You can also override the thread pool size in Rufus Scheduler by setting e.g.:
+
+```
+SidekiqScheduler::Scheduler.instance.rufus_scheduler_options = { max_work_threads: 5 }
+```
+
 ## Notes about running on Multiple Hosts
 
-`cron` and `at` jobs are pushed once regardless of the number of `sidekiq-scheduler` running instances,
+Under normal conditions, `cron` and `at` jobs are pushed once regardless of the number of `sidekiq-scheduler` running instances,
 assumming that time deltas between hosts is less than 24 hours.
 
+Non-normal conditions that could push a specific job multiple times are:
+ - high cpu load + a high number of jobs scheduled at the same time, like 100 jobs
+ - network / redis latency + 28 (see `MAX_WORK_THREADS` https://github.com/jmettraux/rufus-scheduler/blob/master/lib/rufus/scheduler.rb#L41) or more jobs scheduled within the same network latency window
+
 `every`, `interval` and `in` jobs will be pushed once per host.
 
 ## Sidekiq Web Integration
@@ -307,6 +328,18 @@ run Sidekiq::Web
 
 ![Sidekiq Web Integration](https://github.com/moove-it/sidekiq-scheduler/raw/master/images/recurring-jobs-ui-tab.png)
 
+## ActiveJob integration
+
+When using sidekiq-scheduler with ActiveJob your jobs can just extend `ApplicationJob` as usual, without the `require` and `include` boilerplate. Under the hood Rails will load up the scheduler and include the worker module for you.
+
+```rb
+class HelloWorld < ApplicationJob
+  def perform
+    puts 'Hello world'
+  end
+end
+```
+
 ## The Spring preloader and Testing your initializer via Rails console
 
 If you're pulling in your schedule from a YML file via an initializer as shown, be aware that the Spring application preloader included with Rails will interefere with testing via the Rails console.
@@ -327,7 +360,8 @@ something like this in an initializer:
 
 ``` ruby
 # config/initializers/sidekiq_scheduler.rb
-require 'sidekiq/scheduler'
+require 'sidekiq'
+require 'sidekiq-scheduler'
 
 puts "Sidekiq.server? is #{Sidekiq.server?.inspect}"
 puts "defined?(Rails::Server) is #{defined?(Rails::Server).inspect}"
@@ -338,12 +372,12 @@ if Rails.env == 'production' && (defined?(Rails::Server) || defined?(Unicorn))
 
     config.on(:startup) do
       Sidekiq.schedule = YAML.load_file(File.expand_path('../../scheduler.yml', __FILE__))
-      Sidekiq::Scheduler.reload_schedule!
+      SidekiqScheduler::Scheduler.instance.reload_schedule!
     end
   end
 else
-  Sidekiq::Scheduler.enabled = false
-  puts "Sidekiq::Scheduler.enabled is #{Sidekiq::Scheduler.enabled.inspect}"
+  SidekiqScheduler::Scheduler.instance.enabled = false
+  puts "SidekiqScheduler::Scheduler.instance.enabled is #{SidekiqScheduler::Scheduler.instance.enabled.inspect}"
 end
 ```
 
@@ -353,6 +387,6 @@ MIT License
 
 ## Copyright
 
-Copyright 2013 - 2017 Moove-IT.
+Copyright 2013 - 2018 Moove-IT.
 Copyright 2012 Morton Jonuschat.
 Some parts copyright 2010 Ben VandenBos.

data/lib/sidekiq-scheduler.rb

@@ -1,47 +1,24 @@
 require 'sidekiq'
 require 'tilt/erb'
 
+require_relative 'sidekiq/scheduler'
 require_relative 'sidekiq-scheduler/version'
 require_relative 'sidekiq-scheduler/manager'
 require_relative 'sidekiq-scheduler/redis_manager'
+require_relative 'sidekiq-scheduler/extensions/schedule'
 
 Sidekiq.configure_server do |config|
 
   config.on(:startup) do
-    dynamic = Sidekiq::Scheduler.dynamic
-    dynamic = dynamic.nil? ? config.options.fetch(:dynamic, false) : dynamic
-
-    dynamic_every = Sidekiq::Scheduler.dynamic_every
-    dynamic_every = dynamic_every.nil? ? config.options.fetch(:dynamic_every, '5s') : dynamic_every
-
-    enabled = Sidekiq::Scheduler.enabled
-    enabled = enabled.nil? ? config.options.fetch(:enabled, true) : enabled
-
-    scheduler = config.options.fetch(:scheduler, {})
-
-    listened_queues_only = Sidekiq::Scheduler.listened_queues_only
-    listened_queues_only = listened_queues_only.nil? ? scheduler[:listened_queues_only] : listened_queues_only
-
-    schedule = Sidekiq.schedule
-    schedule ||= config.options[:schedule] || {}
-
-    scheduler_options = {
-      dynamic:       dynamic,
-      dynamic_every: dynamic_every,
-      enabled:       enabled,
-      schedule:      schedule,
-      listened_queues_only: listened_queues_only
-    }
-
     # schedules_changed's type was changed from SET to ZSET, so we remove old versions at startup
     SidekiqScheduler::RedisManager.clean_schedules_changed
 
-    schedule_manager = SidekiqScheduler::Manager.new(scheduler_options)
+    schedule_manager = SidekiqScheduler::Manager.new(config.options)
     config.options[:schedule_manager] = schedule_manager
     config.options[:schedule_manager].start
   end
 
-  config.on(:shutdown) do
+  config.on(:quiet) do
     config.options[:schedule_manager].stop
   end
 

data/lib/sidekiq-scheduler/extensions/schedule.rb

@@ -0,0 +1,4 @@
+require 'sidekiq'
+require_relative '../schedule'
+
+Sidekiq.extend SidekiqScheduler::Schedule

data/lib/sidekiq-scheduler/extensions/web.rb

@@ -0,0 +1,5 @@
+require 'sidekiq/web' unless defined?(Sidekiq::Web)
+
+Sidekiq::Web.register(SidekiqScheduler::Web)
+Sidekiq::Web.tabs['recurring_jobs'] = 'recurring-jobs'
+Sidekiq::Web.locales << File.expand_path(File.dirname(__FILE__) + '/../../../web/locales')

data/lib/sidekiq-scheduler/job_presenter.rb

@@ -56,7 +56,7 @@ module SidekiqScheduler
     end
 
     def enabled?
-      Sidekiq::Scheduler.job_enabled?(@name)
+      SidekiqScheduler::Scheduler.job_enabled?(@name)
     end
 
     # Builds the presenter instances for the schedule hash
@@ -66,7 +66,7 @@ module SidekiqScheduler
     def self.build_collection(schedule_hash)
       schedule_hash ||= {}
 
-      schedule_hash.map do |name, job_spec|
+      schedule_hash.sort.map do |name, job_spec|
         new(name, job_spec)
       end
     end

data/lib/sidekiq-scheduler/manager.rb

@@ -2,8 +2,8 @@ require 'redis'
 
 require 'sidekiq/util'
 
-require 'sidekiq/scheduler'
 require 'sidekiq-scheduler/schedule'
+require 'sidekiq-scheduler/scheduler'
 
 module SidekiqScheduler
 
@@ -14,26 +14,48 @@ module SidekiqScheduler
   class Manager
     include Sidekiq::Util
 
+    DEFAULT_SCHEDULER_OPTIONS = {
+      enabled: true,
+      dynamic: false,
+      dynamic_every: '5s',
+      schedule: {}
+    }
+
     def initialize(options)
-      Sidekiq::Scheduler.enabled = options[:enabled]
-      Sidekiq::Scheduler.dynamic = options[:dynamic]
-      Sidekiq::Scheduler.dynamic_every = options[:dynamic_every]
-      Sidekiq::Scheduler.listened_queues_only = options[:listened_queues_only]
-      Sidekiq.schedule = options[:schedule] if Sidekiq::Scheduler.enabled
+      scheduler_options = load_scheduler_options(options)
+
+      @scheduler_instance = SidekiqScheduler::Scheduler.new(scheduler_options)
+      SidekiqScheduler::Scheduler.instance = @scheduler_instance
+      Sidekiq.schedule = scheduler_options[:schedule] if @scheduler_instance.enabled
     end
 
     def stop
-      Sidekiq::Scheduler.clear_schedule!
+      @scheduler_instance.clear_schedule!
     end
 
     def start
-      Sidekiq::Scheduler.load_schedule!
+      @scheduler_instance.load_schedule!
     end
 
     def reset
       clear_scheduled_work
     end
 
-  end
+    private
+
+    def load_scheduler_options(options)
+      options[:listened_queues_only] = options.fetch(:scheduler, {})[:listened_queues_only]
+      scheduler_options = DEFAULT_SCHEDULER_OPTIONS.merge(options)
 
+      current_options = {
+        enabled: SidekiqScheduler::Scheduler.enabled,
+        dynamic: SidekiqScheduler::Scheduler.dynamic,
+        dynamic_every: SidekiqScheduler::Scheduler.dynamic_every,
+        schedule: Sidekiq.schedule,
+        listened_queues_only: SidekiqScheduler::Scheduler.listened_queues_only
+      }.delete_if { |_, value| value.nil? }
+
+      scheduler_options.merge(current_options)
+    end
+  end
 end

data/lib/sidekiq-scheduler/redis_manager.rb

@@ -96,7 +96,13 @@ module SidekiqScheduler
     #
     # @return [Boolean] true if the schedules key is set, false otherwise
     def self.schedule_exist?
-      Sidekiq.redis { |r| r.exists(:schedules) }
+      Sidekiq.redis do |r|
+        if r.respond_to?(:exists?)
+          r.exists?(:schedules)
+        else
+          !!r.exists(:schedules)
+        end
+      end
     end
 
     # Returns all the schedule changes for a given time range.

data/lib/sidekiq-scheduler/schedule.rb

@@ -152,5 +152,3 @@ module SidekiqScheduler
     end
   end
 end
-
-Sidekiq.extend SidekiqScheduler::Schedule

data/lib/sidekiq-scheduler/scheduler.rb

@@ -0,0 +1,357 @@
+require 'rufus/scheduler'
+require 'thwait'
+require 'sidekiq/util'
+require 'json'
+require 'sidekiq-scheduler/rufus_utils'
+require 'sidekiq-scheduler/redis_manager'
+
+module SidekiqScheduler
+  class Scheduler
+    extend Sidekiq::Util
+
+    # We expect rufus jobs to have #params
+    Rufus::Scheduler::Job.module_eval do
+      alias_method :params, :opts
+    end
+
+    # Set to enable or disable the scheduler.
+    attr_accessor :enabled
+
+    # Set to update the schedule in runtime in a given time period.
+    attr_accessor :dynamic
+
+    # Set to update the schedule in runtime dynamically per this period.
+    attr_accessor :dynamic_every
+
+    # Set to schedule jobs only when will be pushed to queues listened by sidekiq
+    attr_accessor :listened_queues_only
+
+    class << self
+
+      def instance
+        @instance = new unless @instance
+        @instance
+      end
+
+      def instance=(value)
+        @instance = value
+      end
+
+      def method_missing(method, *arguments, &block)
+        instance_methods.include?(method) ? instance.public_send(method, *arguments) : super
+      end
+    end
+
+    def initialize(options = {})
+      self.enabled = options[:enabled]
+      self.dynamic = options[:dynamic]
+      self.dynamic_every = options[:dynamic_every]
+      self.listened_queues_only = options[:listened_queues_only]
+    end
+
+    # the Rufus::Scheduler jobs that are scheduled
+    def scheduled_jobs
+      @scheduled_jobs
+    end
+
+    def print_schedule
+      if rufus_scheduler
+        Sidekiq.logger.info "Scheduling Info\tLast Run"
+        scheduler_jobs = rufus_scheduler.all_jobs
+        scheduler_jobs.each_value do |v|
+          Sidekiq.logger.info "#{v.t}\t#{v.last}\t"
+        end
+      end
+    end
+
+    # Pulls the schedule from Sidekiq.schedule and loads it into the
+    # rufus scheduler instance
+    def load_schedule!
+      if enabled
+        Sidekiq.logger.info 'Loading Schedule'
+
+        # Load schedule from redis for the first time if dynamic
+        if dynamic
+          Sidekiq.reload_schedule!
+          @current_changed_score = Time.now.to_f
+          rufus_scheduler.every(dynamic_every) do
+            update_schedule
+          end
+        end
+
+        Sidekiq.logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
+
+        @scheduled_jobs = {}
+        queues = sidekiq_queues
+
+        Sidekiq.schedule.each do |name, config|
+          if !listened_queues_only || enabled_queue?(config['queue'].to_s, queues)
+            load_schedule_job(name, config)
+          else
+            Sidekiq.logger.info { "Ignoring #{name}, job's queue is not enabled." }
+          end
+        end
+
+        Sidekiq.logger.info 'Schedules Loaded'
+      else
+        Sidekiq.logger.info 'SidekiqScheduler is disabled'
+      end
+    end
+
+    # Loads a job schedule into the Rufus::Scheduler and stores it in @scheduled_jobs
+    def load_schedule_job(name, config)
+      # If rails_env is set in the config, enforce ENV['RAILS_ENV'] as
+      # required for the jobs to be scheduled.  If rails_env is missing, the
+      # job should be scheduled regardless of what ENV['RAILS_ENV'] is set
+      # to.
+      if config['rails_env'].nil? || rails_env_matches?(config)
+        Sidekiq.logger.info "Scheduling #{name} #{config}"
+        interval_defined = false
+        interval_types = %w(cron every at in interval)
+        interval_types.each do |interval_type|
+          config_interval_type = config[interval_type]
+
+          if !config_interval_type.nil? && config_interval_type.length > 0
+
+            schedule, options = SidekiqScheduler::RufusUtils.normalize_schedule_options(config_interval_type)
+
+            rufus_job = new_job(name, interval_type, config, schedule, options)
+            @scheduled_jobs[name] = rufus_job
+            SidekiqScheduler::Utils.update_job_next_time(name, rufus_job.next_time)
+
+            interval_defined = true
+
+            break
+          end
+        end
+
+        unless interval_defined
+          Sidekiq.logger.info "no #{interval_types.join(' / ')} found for #{config['class']} (#{name}) - skipping"
+        end
+      end
+    end
+
+    # Pushes the job into Sidekiq if not already pushed for the given time
+    #
+    # @param [String] job_name The job's name
+    # @param [Time] time The time when the job got cleared for triggering
+    # @param [Hash] config Job's config hash
+    def idempotent_job_enqueue(job_name, time, config)
+      registered = SidekiqScheduler::RedisManager.register_job_instance(job_name, time)
+
+      if registered
+        Sidekiq.logger.info "queueing #{config['class']} (#{job_name})"
+
+        handle_errors { enqueue_job(config, time) }
+
+        SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
+      else
+        Sidekiq.logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
+      end
+    end
+
+    # Enqueue a job based on a config hash
+    #
+    # @param job_config [Hash] the job configuration
+    # @param time [Time] time the job is enqueued
+    def enqueue_job(job_config, time = Time.now)
+      config = prepare_arguments(job_config.dup)
+
+      if config.delete('include_metadata')
+        config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
+      end
+
+      if active_job_enqueue?(config['class'])
+        SidekiqScheduler::Utils.enqueue_with_active_job(config)
+      else
+        SidekiqScheduler::Utils.enqueue_with_sidekiq(config)
+      end
+    end
+
+    def rufus_scheduler_options
+      @rufus_scheduler_options ||= {}
+    end
+
+    def rufus_scheduler_options=(options)
+      @rufus_scheduler_options = options
+    end
+
+    def rufus_scheduler
+      @rufus_scheduler ||= SidekiqScheduler::Utils.new_rufus_scheduler(rufus_scheduler_options)
+    end
+
+    # Stops old rufus scheduler and creates a new one.  Returns the new
+    # rufus scheduler
+    #
+    # @param [Symbol] stop_option The option to be passed to Rufus::Scheduler#stop
+    def clear_schedule!(stop_option = :wait)
+      if @rufus_scheduler
+        @rufus_scheduler.stop(stop_option)
+        @rufus_scheduler = nil
+      end
+
+      @@scheduled_jobs = {}
+
+      rufus_scheduler
+    end
+
+    def reload_schedule!
+      if enabled
+        Sidekiq.logger.info 'Reloading Schedule'
+        clear_schedule!
+        load_schedule!
+      else
+        Sidekiq.logger.info 'SidekiqScheduler is disabled'
+      end
+    end
+
+    def update_schedule
+      last_changed_score, @current_changed_score = @current_changed_score, Time.now.to_f
+      schedule_changes = SidekiqScheduler::RedisManager.get_schedule_changes(last_changed_score, @current_changed_score)
+
+      if schedule_changes.size > 0
+        Sidekiq.logger.info 'Updating schedule'
+
+        Sidekiq.reload_schedule!
+        schedule_changes.each do |schedule_name|
+          if Sidekiq.schedule.keys.include?(schedule_name)
+            unschedule_job(schedule_name)
+            load_schedule_job(schedule_name, Sidekiq.schedule[schedule_name])
+          else
+            unschedule_job(schedule_name)
+          end
+        end
+        Sidekiq.logger.info 'Schedule updated'
+      end
+    end
+
+    def job_enabled?(name)
+      job = Sidekiq.schedule[name]
+      schedule_state(name).fetch('enabled', job.fetch('enabled', true)) if job
+    end
+
+    def toggle_job_enabled(name)
+      state = schedule_state(name)
+      state['enabled'] = !job_enabled?(name)
+      set_schedule_state(name, state)
+    end
+
+    private
+
+    def new_job(name, interval_type, config, schedule, options)
+      options = options.merge({ :job => true, :tags => [name] })
+
+      rufus_scheduler.send(interval_type, schedule, options) do |job, time|
+        idempotent_job_enqueue(name, time, SidekiqScheduler::Utils.sanitize_job_config(config)) if job_enabled?(name)
+      end
+    end
+
+    def unschedule_job(name)
+      if scheduled_jobs[name]
+        Sidekiq.logger.debug "Removing schedule #{name}"
+        scheduled_jobs[name].unschedule
+        scheduled_jobs.delete(name)
+      end
+    end
+
+    # Retrieves a schedule state
+    #
+    # @param name [String] with the schedule's name
+    # @return [Hash] with the schedule's state
+    def schedule_state(name)
+      state = SidekiqScheduler::RedisManager.get_job_state(name)
+
+      state ? JSON.parse(state) : {}
+    end
+
+    # Saves a schedule state
+    #
+    # @param name [String] with the schedule's name
+    # @param name [Hash] with the schedule's state
+    def set_schedule_state(name, state)
+      SidekiqScheduler::RedisManager.set_job_state(name, state)
+    end
+
+    # Adds a Hash with schedule metadata as the last argument to call the worker.
+    # It currently returns the schedule time as a Float number representing the milisencods
+    # since epoch.
+    #
+    # @example with hash argument
+    #   arguments_with_metadata({value: 1}, scheduled_at: Time.now)
+    #   #=> [{value: 1}, {scheduled_at: <miliseconds since epoch>}]
+    #
+    # @param args [Array|Hash]
+    # @param metadata [Hash]
+    # @return [Array] arguments with added metadata
+    def arguments_with_metadata(args, metadata)
+      if args.is_a? Array
+        [*args, metadata]
+      else
+        [args, metadata]
+      end
+    end
+
+    def sidekiq_queues
+      Sidekiq.options[:queues].map(&:to_s)
+    end
+
+    # Returns true if a job's queue is included in the array of queues
+    #
+    # If queues are empty, returns true.
+    #
+    # @param [String] job_queue Job's queue name
+    # @param [Array<String>] queues
+    #
+    # @return [Boolean]
+    def enabled_queue?(job_queue, queues)
+      queues.empty? || queues.include?(job_queue)
+    end
+
+    # Returns true if the enqueuing needs to be done for an ActiveJob
+    #  class false otherwise.
+    #
+    # @param [Class] klass the class to check is decendant from ActiveJob
+    #
+    # @return [Boolean]
+    def active_job_enqueue?(klass)
+      klass.is_a?(Class) && defined?(ActiveJob::Enqueuing) &&
+        klass.included_modules.include?(ActiveJob::Enqueuing)
+    end
+
+    # Convert the given arguments in the format expected to be enqueued.
+    #
+    # @param [Hash] config the options to be converted
+    # @option config [String] class the job class
+    # @option config [Hash/Array] args the arguments to be passed to the job
+    #   class
+    #
+    # @return [Hash]
+    def prepare_arguments(config)
+      config['class'] = SidekiqScheduler::Utils.try_to_constantize(config['class'])
+
+      if config['args'].is_a?(Hash)
+        config['args'].symbolize_keys! if config['args'].respond_to?(:symbolize_keys!)
+      else
+        config['args'] = Array(config['args'])
+      end
+
+      config
+    end
+
+    # Returns true if the given schedule config hash matches the current ENV['RAILS_ENV']
+    # @param [Hash] config The schedule job configuration
+    #
+    # @return [Boolean] true if the schedule config matches the current ENV['RAILS_ENV']
+    def rails_env_matches?(config)
+      config['rails_env'] && ENV['RAILS_ENV'] && config['rails_env'].gsub(/\s/, '').split(',').include?(ENV['RAILS_ENV'])
+    end
+
+    def handle_errors
+      begin
+        yield
+      rescue StandardError => e
+        Sidekiq.logger.info "#{e.class.name}: #{e.message}"
+      end
+    end
+  end
+end