sidekiq-scheduler 4.0.2 → 5.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46f14eafd933ccc91c36ba3b52babf250a9d17723d8a321b016bad2caaf36262
-  data.tar.gz: d285ce8992b380f98c05860883c54aa504c83df31aeba252297b1c02d35590a6
+  metadata.gz: adc6f05c8d6f36cedff6c3fb051e7314581cbe1b4e460fe3227ec7c2e11cf842
+  data.tar.gz: d88174e3e2bacf2b4571f9b5a4d758ff5e30e456039dd967fbf1a2ff3440b155
 SHA512:
-  metadata.gz: fe3a692c9419fe21b60333f4801c519fa9eb96b2c49f4f7ad9f6bb41001ac8c0b9884ffa01c19018fe5101e2419f09af3df93f3efcd4de11b87b108d785a5047
-  data.tar.gz: 264780676f625a002b67b88eb03ee12981a2e222889334799e76c1aefde9ec3d35fad50d645233bd27c195113ea14e5af68ad3d82b4f853e7342f6ae2c3d08c3
+  metadata.gz: f41792a0657385179077cda82953df1dfc304af70f80a50355803b5a3b5b33de32e764e043b79874216e2fbbc38997e6fd9dde1ba8a9d3359019ccc86f9ca52e
+  data.tar.gz: 392629ec1306d5ea3d3af1b5a20c23756696d447ee5cee618b5f16b322f0def210c269331248956e43758d6b653257ef123bd73af48de66e49eb019a53b477db

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+# 5.0.0.beta1
+
+- [**BREAKING CHANGE**] Moves all sidekiq-scheduler config options under the `scheduler` key in the `sidekiq.yml` file [#412](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/412)
+  - If you're migrating from v4 to v5, any `sidekiq-scheduler` config you may have in your `sidekiq.yml` should be moved under the `scheduler` key.
+  - See [#412](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/412) to see which are the config options that you need to move under the `scheduler` key.
+  
+- [**BREAKING CHANGE**] Drop support for EOL Ruby & Sidekiq versions (Ruby: `2.5.x` & `2.6.x`; Sidekiq: `4.x` & `5.x`) [#411](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/411)
+
+- [**FIX**] Add support for Sidekiq 7 [#410](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/410)
+
+
+# 4.0.3
+
+- [**GH Actions**] Add dependabot for GitHub Actions [#390](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/390)
+- [**ENHANCEMENT**] Add «Enable all» and «Disable all» buttons [#398](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/398)
+- [**ENHANCEMENT**] Allow for multiple applications to share a Redis DB [#401](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/401)
+- [**FIX**] Fix metadata for Sidekiq strict_args! [#403](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/403)
+- [**FIX**] Redis 5.0 compatibility [#404](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/404)
+- [**FIX**] Fix the constantize method [#408](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/408)
+
 # 4.0.2
 
 - [**FIX**] Fix sidekiq deprecation warning when Sidekiq 6.5+ [#385](https://github.com/sidekiq-scheduler/sidekiq-scheduler/pull/385)

data/README.md

@@ -18,7 +18,7 @@
 `sidekiq-scheduler` is an extension to [Sidekiq](http://github.com/mperham/sidekiq) that
 pushes jobs in a scheduled way, mimicking cron utility.
 
-__Note:__ Current branch contains work of the v4 release, if you are looking for version 2.2.* or 3.*, go to [2.2-stable branch](https://github.com/sidekiq-scheduler/sidekiq-scheduler/tree/2.2-stable) / [v3-stable](https://github.com/sidekiq-scheduler/sidekiq-scheduler/tree/v3-stable).
+__Note:__ Current branch contains work of the upcoming v5 release, if you are looking for version 2.2.\*, 3.\*, or 4.\*, go to [2.2-stable branch](https://github.com/sidekiq-scheduler/sidekiq-scheduler/tree/2.2-stable) / [v3-stable](https://github.com/sidekiq-scheduler/sidekiq-scheduler/tree/v3-stable) / [v4-stable](https://github.com/sidekiq-scheduler/sidekiq-scheduler/tree/v4-stable).
 
 ## Installation
 
@@ -48,10 +48,11 @@ end
 ``` yaml
 # config/sidekiq.yml
 
-:schedule:
-  hello_world:
-    cron: '0 * * * * *'   # Runs once per minute
-    class: HelloWorld
+:scheduler:
+  :schedule:
+    hello_world:
+      cron: '0 * * * * *'   # Runs once per minute
+      class: HelloWorld
 ```
 
 Run sidekiq:
@@ -83,40 +84,41 @@ Configuration options are placed inside `sidekiq.yml` config file.
 Available options are:
 
 ``` yaml
-:dynamic: <if true the schedule can be modified in runtime [false by default]>
-:dynamic_every: <if dynamic is true, the schedule is reloaded every interval [5s by default]>
-:enabled: <enables scheduler if true [true by default]>
 :scheduler:
+  :dynamic: <if true the schedule can be modified in runtime [false by default]>
+  :dynamic_every: <if dynamic is true, the schedule is reloaded every interval [5s by default]>
+  :enabled: <enables scheduler if true [true by default]>
   :listened_queues_only: <push jobs whose queue is being listened by sidekiq [false by default]>
-:rufus_scheduler_options: <Set custom options for rufus scheduler, like max_work_threads [{} by default]>
+  :rufus_scheduler_options: <Set custom options for rufus scheduler, like max_work_threads [{} by default]>
 ```
 
 ## Schedule configuration
 
-The schedule is configured through the `:schedule` config entry in the sidekiq config file:
+The schedule is configured through the `:scheduler:` -> `:schedule` config entry in the sidekiq config file:
 
 ``` yaml
-:schedule:
-  CancelAbandonedOrders:
-    cron: '0 */5 * * * *'   # Runs when second = 0, every 5 minutes
+:scheduler:
+  :schedule:
+    CancelAbandonedOrders:
+      cron: '0 */5 * * * *'   # Runs when second = 0, every 5 minutes
 
-  queue_documents_for_indexing:
-    cron: '0 0 * * * *'   # Runs every hour
+    queue_documents_for_indexing:
+      cron: '0 0 * * * *'   # Runs every hour
 
-    # By default the job name will be taken as worker class name.
-    # If you want to have a different job name and class name, provide the 'class' option
-    class: QueueDocuments
+      # By default the job name will be taken as worker class name.
+      # If you want to have a different job name and class name, provide the 'class' option
+      class: QueueDocuments
 
-    queue: slow
-    args: ['*.pdf']
-    description: "This job queues pdf content for indexing in solr"
+      queue: slow
+      args: ['*.pdf']
+      description: "This job queues pdf content for indexing in solr"
 
-    # Enable the `metadata` argument which will pass a Hash containing the schedule metadata
-    # as the last argument of the `perform` method. `false` by default.
-    include_metadata: true
+      # Enable the `metadata` argument which will pass a Hash containing the schedule metadata
+      # as the last argument of the `perform` method. `false` by default.
+      include_metadata: true
 
-    # Enable / disable a job. All jobs are enabled by default.
-    enabled: true
+      # Enable / disable a job. All jobs are enabled by default.
+      enabled: true
 ```
 
 ### Schedule metadata
@@ -157,9 +159,10 @@ Cron, every, and interval types push jobs into sidekiq in a recurrent manner.
 `cron` follows the same pattern as cron utility, with seconds resolution.
 
 ``` yaml
-:schedule:
-  HelloWorld:
-    cron: '0 * * * * *' # Runs when second = 0
+:scheduler:
+  :schedule:
+    HelloWorld:
+      cron: '0 * * * * *' # Runs when second = 0
 ```
 
 `every` triggers following a given frequency:
@@ -250,7 +253,8 @@ When `:dynamic` flag is set to `true`, schedule changes are loaded every 5 secon
 
 ``` yaml
 # config/sidekiq.yml
-:dynamic: true
+:scheduler:
+  :dynamic: true
 ```
 
 If `:dynamic` flag is set to `false`, you'll have to reload the schedule manually in sidekiq
@@ -299,8 +303,9 @@ You can also override the thread pool size in Rufus Scheduler by setting the fol
 ---
 ...
 
-rufus_scheduler_options:
-  max_work_threads: 5
+:scheduler:
+  rufus_scheduler_options:
+    max_work_threads: 5
 
 ...
 ```
@@ -316,6 +321,47 @@ Non-normal conditions that could push a specific job multiple times are:
 
 `every`, `interval` and `in` jobs will be pushed once per host.
 
+### Suggested setup for Multiple Hosts using Heroku and Rails
+
+Configuration options `every`, `interval` and `in` will push once per host. This may be undesirable. One way to achieve single jobs per the schedule would be to manually designate a host as the scheduler. The goal is to have a single scheduler process running across all your hosts. 
+
+This can be achieved by using an environment variable and controlling the number of dynos. In Rails, you can read this variable during initialization and then conditionally load your config file.
+
+Suppose we are using Rails and have the following schedule:
+
+```yaml
+# config/scheduler.yml
+MyRegularJob:
+  description: "We want this job to run very often, but we do not want to run more of them as we scale"
+  interval: ["1m"]
+  queue: default
+```
+
+Then we can conditionally load it via an initializer:
+
+```ruby
+# config/initializer/sidekiq.rb
+if ENV.fetch("IS_SCHEDULER", false)
+  Sidekiq.configure_server do |config|
+    config.on(:startup) do
+      Sidekiq.schedule = YAML.load_file(File.expand_path("../scheduler.yml", File.dirname(__FILE__)))
+      Sidekiq::Scheduler.reload_schedule!
+    end
+  end
+end
+```
+
+Then you would just need to flag the scheduler process when you start it. If you are using a Procfile, it would look like this:
+
+```yaml
+# Procfile
+web: bin/rails server
+worker: bundle exec sidekiq -q default
+scheduler: IS_SCHEDULER=true bundle exec sidekiq -q default
+```
+
+When running via Heroku, you set your `scheduler` process to have 1 dyno. This will ensure you have at most 1 worker loading the schedule. 
+
 ## Notes on when Sidekiq worker is down
 
 For a `cron`/`at` (and all other) job to be successfully enqueued, you need at least one sidekiq worker with scheduler to be up at that moment. Handling this is up to you and depends on your application.
@@ -345,12 +391,13 @@ Say you have one process with the schedule:
 
 :queues:
   - default
-:schedule:
-  do_something_every_minute:
-    class: DoSomethingJob
-    args: matey
-    queue: :scheduler
-    cron: '0 * * * * * America/Los_Angeles'
+:scheduler:
+  :schedule:
+    do_something_every_minute:
+      class: DoSomethingJob
+      args: matey
+      queue: :scheduler
+      cron: '0 * * * * * America/Los_Angeles'
 ```
 
 And a separate separate configured process without one:
@@ -360,7 +407,8 @@ And a separate separate configured process without one:
   - scheduler
 
 ## NOTE Disable the Scheduler
-:enabled: false
+:scheduler:
+  :enabled: false
 ```
 
 ### Details
@@ -377,6 +425,22 @@ Redis.
 
 See https://github.com/sidekiq-scheduler/sidekiq-scheduler/issues/361 for a more details.
 
+## Notes when running multiple applications in the same Redis database
+
+_NOTE_: **Although we support this option, we recommend having separate redis databases for each application. Choosing this option is at your own risk.**
+
+If you need to run multiple applications with differing schedules, the easiest way is to use a different Redis database per application. Doing that will ensure that each application will have its own schedule, web interface and statistics.
+
+However, you may want to have a set of related applications share the same Redis database in order to aggregate statistics and manage them all in a single web interface. To do this while maintaining a different schedule for each application, you can configure each application to use a different `key_prefix` in Redis. This prevents the applications overwriting each others' schedules and schedule data.
+
+```ruby
+Rails.application.reloader.to_prepare do
+  SidekiqScheduler::RedisManager.key_prefix = "my-app"
+end
+```
+
+Note that this must be set before the schedule is loaded (or it will go into the wrong key). If you are using the web integration, make sure that the prefix is set in the web process so that you see the correct schedule.
+
 ## Sidekiq Web Integration
 
 sidekiq-scheduler provides an extension to the Sidekiq web interface that adds a `Recurring Jobs` page.

data/lib/sidekiq-scheduler/config.rb

@@ -0,0 +1,80 @@
+module SidekiqScheduler
+  class Config
+    # We have to set the default as nil because the scheduler could be instantiated without
+    # passing the sidekiq config, and in those scenarios we don't want to fail
+    def initialize(sidekiq_config: nil, without_defaults: false)
+      @sidekiq_config = sidekiq_config
+      @scheduler_config = fetch_scheduler_config(sidekiq_config, without_defaults)
+    end
+
+    def enabled?
+      scheduler_config[:enabled]
+    end
+
+    def enabled=(value)
+      scheduler_config[:enabled] = value
+    end
+
+    def dynamic?
+      scheduler_config[:dynamic]
+    end
+
+    def dynamic=(value)
+      scheduler_config[:dynamic] = value
+    end
+
+    def dynamic_every?
+      scheduler_config[:dynamic_every]
+    end
+
+    def dynamic_every=(value)
+      scheduler_config[:dynamic_every] = value
+    end
+
+    def schedule
+      scheduler_config[:schedule]
+    end
+
+    def schedule=(value)
+      scheduler_config[:schedule] = value
+    end
+
+    def listened_queues_only?
+      scheduler_config[:listened_queues_only]
+    end
+
+    def listened_queues_only=(value)
+      scheduler_config[:listened_queues_only] = value
+    end
+
+    def rufus_scheduler_options
+      scheduler_config[:rufus_scheduler_options]
+    end
+
+    def rufus_scheduler_options=(value)
+      scheduler_config[:rufus_scheduler_options] = value
+    end
+
+    def sidekiq_queues
+      SidekiqScheduler::SidekiqAdapter.sidekiq_queues(sidekiq_config)
+    end
+
+    private
+
+    attr_reader :scheduler_config
+    attr_reader :sidekiq_config
+
+    DEFAULT_OPTIONS = {
+      enabled: true,
+      dynamic: false,
+      dynamic_every: '5s',
+      schedule: {},
+      rufus_scheduler_options: {}
+    }.freeze
+
+    def fetch_scheduler_config(sidekiq_config, without_defaults)
+      conf = SidekiqScheduler::SidekiqAdapter.fetch_scheduler_config_from_sidekiq(sidekiq_config)
+      without_defaults ? conf : DEFAULT_OPTIONS.merge(conf)
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ Sidekiq::Web.tabs['recurring_jobs'] = 'recurring-jobs'
 Sidekiq::Web.locales << File.expand_path("#{File.dirname(__FILE__)}/../../../web/locales")
 
 if Sidekiq::VERSION >= '6.0.0'
-  Sidekiq::Web.use Rack::Static, urls: ['/stylesheets'],
+  Sidekiq::Web.use Rack::Static, urls: ['/stylesheets-scheduler'],
                                  root: ASSETS_PATH,
                                  cascade: true,
                                  header_rules: [[:all, { 'Cache-Control' => 'public, max-age=86400' }]]

data/lib/sidekiq-scheduler/manager.rb

@@ -10,19 +10,12 @@ module SidekiqScheduler
   # from Redis onto the work queues
   #
   class Manager
-    DEFAULT_SCHEDULER_OPTIONS = {
-      enabled: true,
-      dynamic: false,
-      dynamic_every: '5s',
-      schedule: {}
-    }
+    def initialize(config)
+      set_current_scheduler_options(config)
 
-    def initialize(options)
-      scheduler_options = load_scheduler_options(options)
-
-      @scheduler_instance = SidekiqScheduler::Scheduler.new(scheduler_options)
+      @scheduler_instance = SidekiqScheduler::Scheduler.new(config)
       SidekiqScheduler::Scheduler.instance = @scheduler_instance
-      Sidekiq.schedule = scheduler_options[:schedule] if @scheduler_instance.enabled
+      Sidekiq.schedule = config.schedule if @scheduler_instance.enabled
     end
 
     def stop
@@ -35,19 +28,17 @@ module SidekiqScheduler
 
     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)
+    def set_current_scheduler_options(config)
+      enabled = SidekiqScheduler::Scheduler.enabled
+      dynamic = SidekiqScheduler::Scheduler.dynamic
+      dynamic_every = SidekiqScheduler::Scheduler.dynamic_every
+      listened_queues_only = SidekiqScheduler::Scheduler.listened_queues_only
+
+      config.enabled = enabled unless enabled.nil?
+      config.dynamic = dynamic unless dynamic.nil?
+      config.dynamic_every = dynamic_every unless dynamic_every.nil?
+      config.schedule = Sidekiq.schedule if Sidekiq.schedule.present?
+      config.listened_queues_only = listened_queues_only unless listened_queues_only.nil?
     end
   end
 end

data/lib/sidekiq-scheduler/redis_manager.rb

@@ -9,7 +9,7 @@ module SidekiqScheduler
     #
     # @return [String] schedule in JSON format
     def self.get_job_schedule(name)
-      hget('schedules', name)
+      hget(schedules_key, name)
     end
 
     # Returns the state of a given job
@@ -44,7 +44,7 @@ module SidekiqScheduler
     # @param [String] name The name of the job
     # @param [Hash] config The new schedule for the job
     def self.set_job_schedule(name, config)
-      hset('schedules', name, JSON.generate(config))
+      hset(schedules_key, name, JSON.generate(config))
     end
 
     # Sets the state for a given job
@@ -60,7 +60,7 @@ module SidekiqScheduler
     # @param [String] name The name of the job
     # @param [String] next_time The next time the job has to be executed
     def self.set_job_next_time(name, next_time)
-      hset(next_times_key, name, next_time)
+      hset(next_times_key, name, String(next_time))
     end
 
     # Sets the last execution time for a given job
@@ -68,14 +68,14 @@ module SidekiqScheduler
     # @param [String] name The name of the job
     # @param [String] last_time The last time the job was executed
     def self.set_job_last_time(name, last_time)
-      hset(last_times_key, name, last_time)
+      hset(last_times_key, name, String(last_time))
     end
 
     # Removes the schedule for a given job
     #
     # @param [String] name The name of the job
     def self.remove_job_schedule(name)
-      hdel('schedules', name)
+      hdel(schedules_key, name)
     end
 
     # Removes the next execution time for a given job
@@ -89,14 +89,14 @@ module SidekiqScheduler
     #
     # @return [Hash] hash with all the job schedules
     def self.get_all_schedules
-      Sidekiq.redis { |r| r.hgetall('schedules') }
+      Sidekiq.redis { |r| r.hgetall(schedules_key) }
     end
 
     # Returns boolean value that indicates if the schedules value exists
     #
     # @return [Boolean] true if the schedules key is set, false otherwise
     def self.schedule_exist?
-      Sidekiq.redis { |r| r.exists?('schedules') }
+      SidekiqScheduler::SidekiqAdapter.redis_key_exists?(schedules_key)
     end
 
     # Returns all the schedule changes for a given time range.
@@ -106,19 +106,19 @@ module SidekiqScheduler
     #
     # @return [Array] array with all the changed job names
     def self.get_schedule_changes(from, to)
-      Sidekiq.redis { |r| r.zrangebyscore('schedules_changed', from, "(#{to}") }
+      Sidekiq.redis { |r| r.zrangebyscore(schedules_changed_key, from, "(#{to}") }
     end
 
     # Register a schedule change for a given job
     #
     # @param [String] name The name of the job
     def self.add_schedule_change(name)
-      Sidekiq.redis { |r| r.zadd('schedules_changed', Time.now.to_f, name) }
+      Sidekiq.redis { |r| r.zadd(schedules_changed_key, Time.now.to_f, name) }
     end
 
     # Remove all the schedule changes records
     def self.clean_schedules_changed
-      Sidekiq.redis { |r| r.del('schedules_changed') unless r.type('schedules_changed') == 'zset' }
+      Sidekiq.redis { |r| r.del(schedules_changed_key) unless r.type(schedules_changed_key) == 'zset' }
     end
 
     # Removes a queued job instance
@@ -136,7 +136,7 @@ module SidekiqScheduler
         end
       end
 
-      registered
+      registered.instance_of?(Integer) ? (registered > 0) : registered
     end
 
     # Removes instances of the job older than 24 hours
@@ -156,32 +156,61 @@ module SidekiqScheduler
     #
     # @return [String] the pushed job key
     def self.pushed_job_key(job_name)
-      "sidekiq-scheduler:pushed:#{job_name}"
+      "#{key_prefix}sidekiq-scheduler:pushed:#{job_name}"
     end
 
     # Returns the key of the Redis hash for job's execution times hash
     #
     # @return [String] with the key
     def self.next_times_key
-      'sidekiq-scheduler:next_times'
+      "#{key_prefix}sidekiq-scheduler:next_times"
     end
 
     # Returns the key of the Redis hash for job's last execution times hash
     #
     # @return [String] with the key
     def self.last_times_key
-      'sidekiq-scheduler:last_times'
+      "#{key_prefix}sidekiq-scheduler:last_times"
     end
 
     # Returns the Redis's key for saving schedule states.
     #
     # @return [String] with the key
     def self.schedules_state_key
-      'sidekiq-scheduler:states'
+      "#{key_prefix}sidekiq-scheduler:states"
+    end
+
+    # Returns the Redis's key for saving schedules.
+    #
+    # @return [String] with the key
+    def self.schedules_key
+      "#{key_prefix}schedules"
+    end
+
+    # Returns the Redis's key for saving schedule changes.
+    #
+    # @return [String] with the key
+    def self.schedules_changed_key
+      "#{key_prefix}schedules_changed"
+    end
+
+    # Returns the key prefix used to generate all scheduler keys
+    #
+    # @return [String] with the key prefix
+    def self.key_prefix
+      @key_prefix
+    end
+
+    # Sets the key prefix used to scope all scheduler keys
+    #
+    # @param [String] value The string to use as the prefix. A ":" will be appended as a delimiter if needed.
+    def self.key_prefix=(value)
+      value = "#{value}:" if value && !%w[. :].include?(value[-1])
+      @key_prefix = value
     end
 
     private
-    
+
     # Returns the value of a Redis stored hash field
     #
     # @param [String] hash_key The key name of the hash

data/lib/sidekiq-scheduler/schedule.rb

@@ -148,9 +148,7 @@ module SidekiqScheduler
     end
 
     def try_to_constantize(klass)
-      klass.is_a?(String) ? klass.constantize : klass
-    rescue NameError
-      klass
+      SidekiqScheduler::Utils.try_to_constantize(klass)
     end
   end
 end

data/lib/sidekiq-scheduler/scheduler.rb

@@ -2,6 +2,7 @@ require 'rufus/scheduler'
 require 'json'
 require 'sidekiq-scheduler/rufus_utils'
 require 'sidekiq-scheduler/redis_manager'
+require 'sidekiq-scheduler/config'
 
 module SidekiqScheduler
   class Scheduler
@@ -10,6 +11,15 @@ module SidekiqScheduler
       alias_method :params, :opts
     end
 
+    # TODO: Can we remove those attr_accessor's? If we need to keep them, we should
+    # update those values on the config object instead of just here in the scheduler.
+    # That's why we need to do what we do in the set_current_scheduler_options (not
+    # saying we will have to do it somehow still)
+    #
+    # NOTE: ^ Keeping this TODO here for now, in a future version of this project
+    # we will remove those attr acessors and use only our config object. For now, 
+    # let's keep as it is.
+
     # Set to enable or disable the scheduler.
     attr_accessor :enabled
 
@@ -41,12 +51,14 @@ module SidekiqScheduler
       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]
-      self.rufus_scheduler_options = options[:rufus_scheduler_options] || {}
+    def initialize(config = SidekiqScheduler::Config.new(without_defaults: true))
+      @scheduler_config = config
+
+      self.enabled = config.enabled?
+      self.dynamic = config.dynamic?
+      self.dynamic_every = config.dynamic_every?
+      self.listened_queues_only = config.listened_queues_only?
+      self.rufus_scheduler_options = config.rufus_scheduler_options
     end
 
     # the Rufus::Scheduler jobs that are scheduled
@@ -82,7 +94,7 @@ module SidekiqScheduler
         Sidekiq.logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
 
         @scheduled_jobs = {}
-        queues = sidekiq_queues
+        queues = scheduler_config.sidekiq_queues
 
         Sidekiq.schedule.each do |name, config|
           if !listened_queues_only || enabled_queue?(config['queue'].to_s, queues)
@@ -158,7 +170,7 @@ module SidekiqScheduler
       config = prepare_arguments(job_config.dup)
 
       if config.delete('include_metadata')
-        config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
+        config['args'] = arguments_with_metadata(config['args'], "scheduled_at" => time.to_f)
       end
 
       if SidekiqScheduler::Utils.active_job_enqueue?(config['class'])
@@ -228,8 +240,18 @@ module SidekiqScheduler
       set_schedule_state(name, state)
     end
 
+    def toggle_all_jobs(new_state)
+      Sidekiq.schedule!.keys.each do |name|
+        state = schedule_state(name)
+        state['enabled'] = new_state
+        set_schedule_state(name, state)
+      end
+    end
+
     private
 
+    attr_reader :scheduler_config
+
     def new_job(name, interval_type, config, schedule, options)
       options = options.merge({ :job => true, :tags => [name] })
 
@@ -283,14 +305,6 @@ module SidekiqScheduler
       end
     end
 
-    def sidekiq_queues
-      if SIDEKIQ_GTE_6_5_0
-        Sidekiq[:queues].map(&:to_s)
-      else
-        Sidekiq.options[:queues].map(&:to_s)
-      end
-    end
-
     # Returns true if a job's queue is included in the array of queues
     #
     # If queues are empty, returns true.

data/lib/sidekiq-scheduler/sidekiq_adapter.rb

@@ -0,0 +1,80 @@
+module SidekiqScheduler
+  class OptionNotSupportedAnymore < StandardError; end
+
+  class SidekiqAdapter
+    SIDEKIQ_GTE_6_5_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
+    SIDEKIQ_GTE_7_0_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('7.0.0')
+
+    def self.fetch_scheduler_config_from_sidekiq(sidekiq_config)
+      return {} if sidekiq_config.nil?
+
+      check_using_old_sidekiq_scheduler_config!(sidekiq_config)
+
+      if SIDEKIQ_GTE_6_5_0
+        sidekiq_config.fetch(:scheduler, {})
+      else
+        sidekiq_config.options.fetch(:scheduler, {})
+      end
+    end
+
+    def self.check_using_old_sidekiq_scheduler_config!(sidekiq_config)
+      %i[enabled dynamic dynamic_every schedule listened_queues_only rufus_scheduler_options].each do |option|
+        if SIDEKIQ_GTE_7_0_0
+          if sidekiq_config.key?(option)
+            raise OptionNotSupportedAnymore, ":#{option} option should be under the :scheduler: key"
+          end
+        elsif SIDEKIQ_GTE_6_5_0
+          unless sidekiq_config[option].nil?
+            raise OptionNotSupportedAnymore, ":#{option} option should be under the :scheduler: key"
+          end
+        else
+          if sidekiq_config.options.key?(option)
+            raise OptionNotSupportedAnymore, ":#{option} option should be under the :scheduler: key"
+          end
+        end
+      end
+    end
+
+    def self.start_schedule_manager(sidekiq_config:, schedule_manager:)
+      if SIDEKIQ_GTE_6_5_0
+        sidekiq_config[:schedule_manager] = schedule_manager
+        sidekiq_config[:schedule_manager].start
+      else
+        sidekiq_config.options[:schedule_manager] = schedule_manager
+        sidekiq_config.options[:schedule_manager].start
+      end
+    end
+
+    def self.stop_schedule_manager(sidekiq_config:)
+      if SIDEKIQ_GTE_6_5_0
+        sidekiq_config[:schedule_manager].stop
+      else
+        sidekiq_config.options[:schedule_manager].stop
+      end
+    end
+
+    def self.sidekiq_queues(sidekiq_config)
+      if SIDEKIQ_GTE_7_0_0
+        if sidekiq_config.present?
+          sidekiq_config.queues.map(&:to_s)
+        else
+          Sidekiq.instance_variable_get(:@config).queues.map(&:to_s)
+        end
+      elsif SIDEKIQ_GTE_6_5_0
+        Sidekiq[:queues].map(&:to_s)
+      else
+        Sidekiq.options[:queues].map(&:to_s)
+      end
+    end
+
+    def self.redis_key_exists?(key_name)
+      Sidekiq.redis do |r|
+        if SIDEKIQ_GTE_7_0_0
+          r.exists(key_name) > 0
+        else
+          r.exists?(key_name)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq-scheduler/utils.rb

@@ -49,7 +49,7 @@ module SidekiqScheduler
     #
     # @return [Class] the class corresponding to the klass param
     def self.try_to_constantize(klass)
-      klass.is_a?(String) ? klass.constantize : klass
+      klass.is_a?(String) ? Object.const_get(klass) : klass
     rescue NameError
       klass
     end
@@ -112,8 +112,10 @@ module SidekiqScheduler
     def self.new_rufus_scheduler(options = {})
       Rufus::Scheduler.new(options).tap do |scheduler|
         scheduler.define_singleton_method(:on_post_trigger) do |job, triggered_time|
-          SidekiqScheduler::Utils.update_job_last_time(job.tags[0], triggered_time)
-          SidekiqScheduler::Utils.update_job_next_time(job.tags[0], job.next_time)
+          if (job_name = job.tags[0])
+            SidekiqScheduler::Utils.update_job_last_time(job_name, triggered_time)
+            SidekiqScheduler::Utils.update_job_next_time(job_name, job.next_time)
+          end
         end
       end
     end

data/lib/sidekiq-scheduler/version.rb

@@ -1,3 +1,3 @@
 module SidekiqScheduler
-  VERSION = "4.0.2"
+  VERSION = "5.0.0.beta1"
 end

data/lib/sidekiq-scheduler/web.rb

@@ -3,7 +3,7 @@ require 'sidekiq-scheduler'
 require_relative 'job_presenter'
 
 module SidekiqScheduler
-  # Hook into *Sidekiq::Web* Sinatra app which adds a new '/recurring-jobs' page
+  # Hook into *Sidekiq::Web* app which adds a new '/recurring-jobs' page
 
   module Web
     VIEW_PATH = File.expand_path('../../../web/views', __FILE__)
@@ -27,6 +27,11 @@ module SidekiqScheduler
         SidekiqScheduler::Scheduler.instance.toggle_job_enabled(params[:name])
         redirect "#{root_path}recurring-jobs"
       end
+
+      app.post '/recurring-jobs/toggle-all' do
+        SidekiqScheduler::Scheduler.instance.toggle_all_jobs(params[:action] == 'enable')
+        redirect "#{root_path}recurring-jobs"
+      end
     end
   end
 end

data/lib/sidekiq-scheduler.rb

@@ -5,9 +5,9 @@ require_relative 'sidekiq/scheduler'
 require_relative 'sidekiq-scheduler/version'
 require_relative 'sidekiq-scheduler/manager'
 require_relative 'sidekiq-scheduler/redis_manager'
+require_relative 'sidekiq-scheduler/config'
 require_relative 'sidekiq-scheduler/extensions/schedule'
-
-SIDEKIQ_GTE_6_5_0 = Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('6.5.0')
+require_relative 'sidekiq-scheduler/sidekiq_adapter'
 
 Sidekiq.configure_server do |config|
 
@@ -15,25 +15,14 @@ Sidekiq.configure_server do |config|
     # schedules_changed's type was changed from SET to ZSET, so we remove old versions at startup
     SidekiqScheduler::RedisManager.clean_schedules_changed
 
-    # Accessing the raw @config hash through .options is deprecated in 6.5 and to be removed in 7.0
-    config_options = SIDEKIQ_GTE_6_5_0 ? Sidekiq.instance_variable_get(:@config) : config.options
+    scheduler_config = SidekiqScheduler::Config.new(sidekiq_config: config)
 
-    schedule_manager = SidekiqScheduler::Manager.new(config_options)
-    if SIDEKIQ_GTE_6_5_0
-      config[:schedule_manager] = schedule_manager
-      config[:schedule_manager].start
-    else
-      config.options[:schedule_manager] = schedule_manager
-      config.options[:schedule_manager].start
-    end
+    schedule_manager = SidekiqScheduler::Manager.new(scheduler_config)
+    SidekiqScheduler::SidekiqAdapter.start_schedule_manager(sidekiq_config: config, schedule_manager: schedule_manager)
   end
 
   config.on(:quiet) do
-    if SIDEKIQ_GTE_6_5_0
-      config[:schedule_manager].stop
-    else
-      config.options[:schedule_manager].stop
-    end
+    SidekiqScheduler::SidekiqAdapter.stop_schedule_manager(sidekiq_config: config)
   end
 
 end

data/web/assets/{stylesheets → stylesheets-scheduler}/recurring_jobs.css

@@ -25,3 +25,18 @@
     border: 1px solid #555;
   }
 }
+
+.toggle-all-buttons {
+  margin-top: 20px;
+  margin-bottom: 10px;
+  line-height: 45px;
+  text-align: right;
+}
+
+@media (max-width: 768px) {
+  .toggle-all-buttons {
+    margin-top: 0;
+    text-align: left;
+    line-height: inherit;
+  }
+}

data/web/locales/de.yml

@@ -12,3 +12,5 @@ de:
   no_next_time: Keine zukünftige Ausführung für diesen Job
   disable: Deaktivieren
   enable: Aktivieren
+  disable_all: Alle deaktivieren
+  enable_all: Alle aktivieren

data/web/locales/en.yml

@@ -12,3 +12,5 @@ en:
   no_next_time: no next execution for this job
   disable: Disable
   enable: Enable
+  disable_all: Disable all
+  enable_all: Enable all

data/web/locales/ru.yml

@@ -12,3 +12,5 @@ ru:
   no_next_time: выполнение задачи не запланировано
   disable: Выключить
   enable: Включить
+  disable_all: Выключить все
+  enable_all: Включить все

data/web/views/recurring_jobs.erb

@@ -1,5 +1,5 @@
 <% if Sidekiq::VERSION >= '6.0.0' %>
-  <link href="<%= root_path %>stylesheets/recurring_jobs.css" media="screen" rel="stylesheet" type="text/css" />
+  <link href="<%= root_path %>stylesheets-scheduler/recurring_jobs.css" media="screen" rel="stylesheet" type="text/css" />
 <% else %>
   <style>
     .recurring-jobs { border-top-left-radius: 4px; border-top-right-radius: 4px; }
@@ -21,10 +21,36 @@
     .list-group-item-disabled {
       background-color: #f3d3d3;
     }
+
+    .toggle-all-buttons {
+      margin-top: 20px;
+      margin-bottom: 10px;
+      line-height: 45px;
+      text-align: right;
+    }
+
+    @media (max-width: 768px) {
+      .toggle-all-buttons {
+        margin-top: 0;
+        text-align: left;
+        line-height: inherit;
+      }
+    }
   </style>
 <% end %>
 
-<h3><%= t('recurring_jobs') %></h3>
+<div class="row">
+  <div class="col-sm-6">
+    <h3><%= t('recurring_jobs') %></h3>
+  </div>
+  <div class="col-sm-6 toggle-all-buttons">
+    <form action="<%= root_path %>recurring-jobs/toggle-all" method="post">
+      <%= csrf_tag %>
+      <button type="submit" class="btn btn-warn btn-xs" name="action" value="enable"><%= t('enable_all') %></button>
+      <button type="submit" class="btn btn-warn btn-xs" name="action" value="disable"><%= t('disable_all') %></button>
+    </form>
+  </div>
+</div>
 
 <div class="recurring-jobs">
   <ul class="list-group">

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-scheduler
 version: !ruby/object:Gem::Version
-  version: 4.0.2
+  version: 5.0.0.beta1
 platform: ruby
 authors:
 - Morton Jonuschat
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-27 00:00:00.000000000 Z
+date: 2022-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -19,6 +19,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,20 +29,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4'
-- !ruby/object:Gem::Dependency
-  name: redis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.2.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: rufus-scheduler
   requirement: !ruby/object:Gem::Requirement
@@ -74,14 +66,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -111,33 +103,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
-  name: mock_redis
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.28.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.28.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -195,19 +187,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sinatra
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 description: Light weight job scheduling extension for Sidekiq that adds support for
   queueing jobs in a recurring way.
 email:
@@ -222,6 +214,7 @@ files:
 - README.md
 - Rakefile
 - lib/sidekiq-scheduler.rb
+- lib/sidekiq-scheduler/config.rb
 - lib/sidekiq-scheduler/extensions/schedule.rb
 - lib/sidekiq-scheduler/extensions/web.rb
 - lib/sidekiq-scheduler/job_presenter.rb
@@ -230,11 +223,12 @@ files:
 - lib/sidekiq-scheduler/rufus_utils.rb
 - lib/sidekiq-scheduler/schedule.rb
 - lib/sidekiq-scheduler/scheduler.rb
+- lib/sidekiq-scheduler/sidekiq_adapter.rb
 - lib/sidekiq-scheduler/utils.rb
 - lib/sidekiq-scheduler/version.rb
 - lib/sidekiq-scheduler/web.rb
 - lib/sidekiq/scheduler.rb
-- web/assets/stylesheets/recurring_jobs.css
+- web/assets/stylesheets-scheduler/recurring_jobs.css
 - web/locales/cs.yml
 - web/locales/de.yml
 - web/locales/en.yml
@@ -261,14 +255,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.19
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Light weight job scheduling extension for Sidekiq