resque-scheduler 5.0.1 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 046040c8fa18b0cb7aabc7fdc46ff008f7b0c30f9aa0500137f5c6c987bdbabc
-  data.tar.gz: b3e243c3c9ccefa0c1282b492b70a9b26677fa2b4be6ead096e339c721d9f86a
+  metadata.gz: 7a49c095f83e23c0bb20e1dffe6038c64a50376d89a0123436eae4233a74e390
+  data.tar.gz: 80bd2fb3055d7904d0d62f47f3683c5c6a6f5c4d7236d7311b29ee7c6d2f1174
 SHA512:
-  metadata.gz: 8b6c3caa8b47c24aee900d2c348cabb20d1a32a5fce88e02a974649ca6c711b1703562393902c7638e14c1a11180b1901b126480e905c7cca8b2dbd47d27daa3
-  data.tar.gz: 7b2665804103943b3bf9a98b84134ba71a0ac00ace8e0c2ed7c765873445c801bea14c8ae9082fec4133e6f3be0314bdf1485ecd47c7bab8aba6d8d85ef36ec8
+  metadata.gz: c206ceb2414921369b7fd89800f95a8e3583226d709fd6d92effbfa69c1284711081cd46189b05aee1d14fdc3161f3d8fee0d7588c4e81a0a2cff6a791c0e415
+  data.tar.gz: f99d4d481f7ec3de91bef5a3b5ead66474e0f1df72a68bb705058de727ed448cd60cae39b901fd0b3edd4d02004fb87147e08a7b265517ca2b5109e194d7fb54

data/.github/workflows/ruby.yml

@@ -6,9 +6,11 @@ on:
   pull_request:
     branches: [master]
 
+permissions:
+  contents: read
+
 jobs:
   test:
-    continue-on-error: true
     runs-on: ubuntu-latest
     services:
       redis:
@@ -19,20 +21,16 @@ jobs:
       fail-fast: false
       matrix:
         ruby-version:
-          - "3.0"
-          - 3.1
           - 3.2
           - 3.3
           - 3.4
+          - "4.0"
           - head
         resque-version:
           - "master"
-        rufus-scheduler:
-          - "3.4"
-          - "3.5"
-          - "3.6"
         redis-version:
           - "4.8"
+          - "5.4"
           - "latest"
         rack-version:
           - 2
@@ -40,15 +38,24 @@ jobs:
     env:
       REDIS_VERSION: "${{ matrix.redis-version }}"
       RESQUE: "${{ matrix.resque-version }}"
-      RUFUS_SCHEDULER: "${{ matrix.rufus-scheduler }}"
       RACK_VERSION: "${{ matrix.rack-version }}"
       COVERAGE: 1
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: "${{ matrix.ruby-version }}"
           bundler-cache: true
       - run: bundle exec rake
       - run: bin/bundle_console_test.sh
+
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.4
+          bundler-cache: true
+      - run: bundle exec rubocop

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 **ATTN**: This project uses [semantic versioning](http://semver.org/).
 
+## [5.1.1] - 2026-11-02
+### Fixed
+* Enqueue batched delayed jobs outside the Redis transaction so a conflicted batch is no longer enqueued twice and enqueue hooks can use Redis by @neuromanskie in #850
+* Skip due delayed items when not master instead of spinning on them by @neuromanskie in #852
+* Load the web UI after Rails initialization to avoid a circular require warning by @neuromanskie in #854
+
+## [5.1.0] - 2026-10-28
+### Breaking Changes
+* Ruby requirement: `>= 3.0.0` → `>= 3.2.0` by @neuromanskie in #837
+* rufus-scheduler dependency: `~> 3.2, != 3.3` → `~> 3.9` by @neuromanskie in #837
+* Schedule entries (`cron`/`every`) no longer run `before_schedule`, `after_schedule` or `before_delayed_enqueue`. Move that code to `before_recurring`/`after_recurring` by @top-sigrid in #844
+
+### Added
+* `before_recurring` and `after_recurring` hooks for jobs enqueued from the schedule by @top-sigrid in #844
+* `DISABLE_DELAYED_REQUEUE_BATCHES` to opt out of batched delayed job enqueues by @onyxraven in #796
+* Search delayed jobs by args in the web UI by @bmo in #839 (originally #714)
+* Allow a number of seconds for `every` by @carsonreinke in #838 (originally #607)
+* Railtie to load resque-scheduler automatically in Rails apps by @josh-m-sharpe in #694
+* Add Ruby 4.0 and redis-rb 5.4 to the CI matrix by @neuromanskie in #837
+
+### Changed
+* Upgrade RuboCop to 1.91 and run it as a CI job by @neuromanskie in #837
+
+### Fixed
+* Delayed jobs no longer run `before_schedule`/`after_schedule` a second time when they become due by @top-sigrid in #844
+* Skip schedule hooks when `enqueue_at` is given a timestamp that is not in the future by @top-sigrid in #817
+* Schedule Active Job classes through `perform_later` by @neuromanskie and @josh-m-sharpe in #842 (originally #696)
+* Schedule delayed test jobs far enough out to not race the clock by @neuromanskie in #843
+* Fail CI when tests fail by @neuromanskie in #837
+
 ## [5.0.1] - 2026-10-11
 ### Changed
 * Pipeline `count_all_scheduled_jobs` for significantly faster execution by @top-sigrid in #822

data/Gemfile

@@ -8,13 +8,6 @@ else
   gem 'resque', resque_version
 end
 
-case rufus_scheduler_version = ENV.fetch('RUFUS_SCHEDULER', '3.6')
-when 'master'
-  gem 'rufus-scheduler', git: 'https://github.com/jmettraux/rufus-scheduler'
-else
-  gem 'rufus-scheduler', rufus_scheduler_version
-end
-
 case redis_version = ENV.fetch('REDIS_VERSION', 'latest')
 when 'master'
   gem 'redis', git: 'https://github.com/redis/redis-rb'

data/README.md

@@ -48,6 +48,9 @@ Adding the resque:scheduler rake task:
 require 'resque/scheduler/tasks'
 ```
 
+In a Rails app, you can skip this step. A Railtie loads the
+`resque:scheduler` rake task and the Resque web UI tabs automatically.
+
 ### Rake integration
 
 By default, `resque-scheduler` depends on the "resque:setup" rake task.
@@ -131,6 +134,8 @@ environment variables:
 * `APP_NAME` - Application name used in procline (`$0`) (default empty)
 * `BACKGROUND` - [Run in the background](#running-in-the-background) if
 non-empty (via `Process.daemon`, if supported) (default `false`)
+* `DELAYED_REQUEUE_BATCH_SIZE` - Set the delayed job batch size if enabled (default `100`). If `<= 1`, this disables batching.
+* `DISABLE_DELAYED_REQUEUE_BATCHES` - Disable batched delayed job queuing (default `false`)
 * `DYNAMIC_SCHEDULE` - Enables [dynamic scheduling](#dynamic-schedules)
 if non-empty (default `false`)
 * `RAILS_ENV` - Environment to use in procline (`$0`) (default empty)
@@ -199,6 +204,19 @@ Resque.enqueue_at_with_queue(
 )
 ```
 
+#### Active Job
+
+`ActiveJob::Base` subclasses can be passed to `enqueue_at`, `enqueue_in` and
+their `_with_queue` variants, and used as the `class` of a scheduled job. They
+are handed to `perform_later` (with `set(wait_until:)` for delayed jobs), so
+Active Job must be using the `:resque` adapter. The job's `queue_as` applies
+unless a queue is given.
+
+Since the stored class is the adapter's `JobWrapper`, `delayed?`,
+`remove_delayed` and `find_delayed_selection` won't match Active Job classes,
+and [hooks](#hooks) defined on them aren't called. Use Active Job's callbacks
+instead.
+
 The delayed queue is stored in redis and is persisted in the same way the
 standard resque jobs are persisted (redis writing to disk). Delayed jobs differ
 from scheduled jobs in that if your scheduler process is down or workers are
@@ -457,6 +475,8 @@ config[:persist] = true
 Resque.set_schedule(name, config)
 ```
 
+`every` also accepts a number of seconds, so `config[:every] = 1.hour` works too.
+
 Schedules can later be removed by passing their name to the `remove_schedule` method:
 
 ```ruby
@@ -506,13 +526,18 @@ Similar to the `before_enqueue`- and `after_enqueue`-hooks provided in Resque
   the delayed queue. If the hook returns `false`, the job will not be placed on
   the queue.
 * `after_schedule`: Called with the job args after a job is placed on the
-  delayed queue. Any exception raised propagates up to the code with queued the
+  delayed queue. Any exception raised propagates up to the code that queued the
   job.
 * `before_delayed_enqueue`: Called with the job args after the job has been
-  removed from the delayed queue, but not yet put on a normal queue. It is
+  removed from the delayed queue, but not yet put on its work queue. It is
   called before `before_enqueue`-hooks, and on the same job instance as the
   `before_enqueue`-hooks will be invoked on. Return values are ignored.
-* `on_enqueue_failure`: Called with the job args and the exception that was raised
+* `before_recurring`: Called with the job args before a job from the schedule
+  (`cron`, `every` or "Queue now" in resque-web) is put on its work queue. If
+  the hook returns `false`, the job will not be enqueued.
+* `after_recurring`: Called with the job args after a job from the schedule has
+  been put on its work queue, after the `after_enqueue`-hooks.
+* `on_enqueue_failure`: Called with the job config and the exception that was raised
   while enqueueing a job to resque or external application fails.  Return
   values are ignored. For example:
 
@@ -610,6 +635,9 @@ The Delayed tab:
 
 ![The Delayed Tab](http://img.skitch.com/20100111-ne4fcqtc5emkcuwc5qtais2kwx.jpg)
 
+The Delayed tab's search matches job class names, or job arguments when
+"Search Args?" is checked.
+
 #### How do I get the schedule tabs to show up???
 
 To get these to show up you need to pass a file to `resque-web` to tell it to
@@ -752,10 +780,10 @@ This table explains the version requirements for rufus-scheduler
 
 | resque-scheduler | rufus-scheduler |
 |:-----------------|----------------:|
+| `>= 5.1`         | `~> 3.9`        |
 | `~> 4.0`         | `~> 3.0`        |
 | `< 4.0`          | `~> 2.0`        |
 
-
 ### Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md)

data/lib/resque/scheduler/cli.rb

@@ -16,7 +16,9 @@ module Resque
       pidfile: 'PIDFILE',
       poll_sleep_amount: 'RESQUE_SCHEDULER_INTERVAL',
       verbose: 'VERBOSE',
-      lock_timeout: 'LOCK_TIMEOUT'
+      lock_timeout: 'LOCK_TIMEOUT',
+      delayed_requeue_batch_size: 'DELAYED_REQUEUE_BATCH_SIZE',
+      disable_delayed_requeue_batches: 'DISABLE_DELAYED_REQUEUE_BATCHES'
     }.freeze
 
     class Cli
@@ -74,6 +76,20 @@ module Resque
         {
           args: ['-v', '--verbose', 'Run with verbose output [VERBOSE]'],
           callback: ->(options) { ->(v) { options[:verbose] = v } }
+        },
+        {
+          args: [
+            '--delayed-requeue-batch-size [DELAYED_REQUEUE_BATCH_SIZE]',
+            'Delayed requeue batch size'
+          ],
+          callback: ->(options) { ->(d) { options[:delayed_requeue_batch_size] = d } }
+        },
+        {
+          args: [
+            '--disable-delayed-requeue-batches',
+            'Disable delayed requeue batches [DISABLE_DELAYED_REQUEUE_BATCHES]'
+          ],
+          callback: ->(options) { ->(d) { options[:disable_delayed_requeue_batches] = d } }
         }
       ].freeze
 

data/lib/resque/scheduler/configuration.rb

@@ -65,10 +65,23 @@ module Resque
         @app_name ||= environment['APP_NAME']
       end
 
+      # Batch size for requeueing delayed jobs.  If <= 1, this disables batching.
+      # Defaults to 100.
+      attr_writer :delayed_requeue_batch_size
+
       def delayed_requeue_batch_size
         @delayed_requeue_batch_size ||= \
-          ENV['DELAYED_REQUEUE_BATCH_SIZE'].to_i if environment['DELAYED_REQUEUE_BATCH_SIZE']
-        @delayed_requeue_batch_size ||= 100
+          Integer(environment.fetch('DELAYED_REQUEUE_BATCH_SIZE', '100'))
+      end
+
+      attr_writer :disable_delayed_requeue_batches
+
+      def disable_delayed_requeue_batches
+        if @disable_delayed_requeue_batches.nil?
+          to_bool(environment['DISABLE_DELAYED_REQUEUE_BATCHES'])
+        else
+          @disable_delayed_requeue_batches
+        end
       end
 
       # Amount of time in seconds to sleep between polls of the delayed

data/lib/resque/scheduler/delaying_extensions.rb

@@ -10,6 +10,10 @@ module Resque
       # for queueing.  Until timestamp is in the past, the job will
       # sit in the schedule list.
       def enqueue_at(timestamp, klass, *args)
+        if Resque::Scheduler::Util.active_job_class?(klass)
+          return enqueue_at_with_queue(nil, timestamp, klass, *args)
+        end
+
         validate(klass)
         enqueue_at_with_queue(
           queue_from_class(klass), timestamp, klass, *args
@@ -21,19 +25,29 @@ module Resque
       # timestamp has passed. It respects Resque.inline option, by
       # creating the job right away instead of adding to the queue.
       def enqueue_at_with_queue(queue, timestamp, klass, *args)
-        plugin.process_schedule_hooks(klass, *args) do
-          if Resque.inline? || timestamp.to_i <= Time.now.to_i
-            # Just create the job and let resque perform it right away with
-            # inline.  If the class is a custom job class, call self#scheduled
-            # on it. This allows you to do things like
-            # Resque.enqueue_at(timestamp, CustomJobClass, :opt1 => val1).
-            # Otherwise, pass off to Resque.
-            if klass.respond_to?(:scheduled)
-              klass.scheduled(queue, klass.to_s, *args)
-            else
-              Resque.enqueue_to(queue, klass, *args)
-            end
+        if Resque::Scheduler::Util.active_job_class?(klass)
+          return klass.set(**{ wait_until: timestamp, queue: queue }.compact)
+                      .perform_later(*args)
+        end
+
+        if Resque.inline? || timestamp.to_i <= Time.now.to_i
+          # Just create the job and let resque perform it right away with
+          # inline.  If the class is a custom job class, call self#scheduled
+          # on it. This allows you to do things like
+          # Resque.enqueue_at(timestamp, CustomJobClass, :opt1 => val1).
+          # Otherwise, pass off to Resque.
+          #
+          # Note: schedule hooks are NOT called here because the job is not
+          # actually being added to the delayed queue.
+          if klass.respond_to?(:scheduled)
+            klass.scheduled(queue, klass.to_s, *args)
           else
+            Resque.enqueue_to(queue, klass, *args)
+          end
+        else
+          # Job is being added to the delayed queue, so we call the
+          # before_schedule and after_schedule hooks.
+          plugin.process_schedule_hooks(klass, *args) do
             delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
           end
         end
@@ -173,14 +187,14 @@ module Resque
       def enqueue_delayed(klass, *args)
         hash = job_to_hash(klass, args)
         remove_delayed(klass, *args).times do
-          Resque::Scheduler.enqueue_from_config(hash)
+          Resque::Scheduler.enqueue_from_config(hash, :delayed)
         end
       end
 
       def enqueue_delayed_with_queue(klass, queue, *args)
         hash = job_to_hash_with_queue(queue, klass, args)
         remove_delayed_in_queue(klass, queue, *args).times do
-          Resque::Scheduler.enqueue_from_config(hash)
+          Resque::Scheduler.enqueue_from_config(hash, :delayed)
         end
       end
 

data/lib/resque/scheduler/env.rb

@@ -74,6 +74,14 @@ module Resque
           end
 
           c.verbose = !!options[:verbose] if options.key?(:verbose)
+
+          if options.key?(:delayed_requeue_batch_size)
+            c.delayed_requeue_batch_size = Integer(options[:delayed_requeue_batch_size])
+          end
+
+          if options.key?(:disable_delayed_requeue_batches)
+            c.disable_delayed_requeue_batches = !!options[:disable_delayed_requeue_batches]
+          end
         end
       end
       # rubocop:enable Metrics/AbcSize

data/lib/resque/scheduler/plugin.rb

@@ -3,6 +3,8 @@
 module Resque
   module Scheduler
     module Plugin
+      ENQUEUE_HOOKS = %i[delayed recurring].freeze
+
       def self.process_schedule_hooks(klass, *args)
         # the documentation states that if any before_schedule hook returns
         # false, the process should not be enqueued
@@ -12,6 +14,32 @@ module Resque
         run_after_schedule_hooks(klass, *args)
       end
 
+      def self.process_recurring_hooks(klass, *args)
+        return unless run_before_recurring_hooks(klass, *args)
+
+        enqueued = yield
+        run_after_recurring_hooks(klass, *args) if enqueued
+        enqueued
+      end
+
+      def self.validate_enqueue_hooks(hooks)
+        return if hooks.nil? || ENQUEUE_HOOKS.include?(hooks)
+
+        raise ArgumentError, "unknown hooks: #{hooks.inspect}"
+      end
+
+      def self.process_enqueue_hooks(hooks, klass, *args, &block)
+        case hooks
+        when :delayed
+          run_before_delayed_enqueue_hooks(klass, *args)
+          yield
+        when :recurring
+          process_recurring_hooks(klass, *args, &block)
+        else
+          yield
+        end
+      end
+
       def self.hooks(job, pattern)
         job.methods.grep(/^#{pattern}/).sort
       end
@@ -35,6 +63,14 @@ module Resque
       def self.run_after_schedule_hooks(klass, *args)
         run_hooks(klass, 'after_schedule', *args)
       end
+
+      def self.run_before_recurring_hooks(klass, *args)
+        run_hooks(klass, 'before_recurring', *args)
+      end
+
+      def self.run_after_recurring_hooks(klass, *args)
+        run_hooks(klass, 'after_recurring', *args)
+      end
     end
   end
 end

data/lib/resque/scheduler/railtie.rb

@@ -0,0 +1,13 @@
+module Resque
+  module Scheduler
+    class Railtie < Rails::Railtie
+      config.after_initialize do
+        require 'resque/scheduler/server'
+      end
+
+      rake_tasks do
+        require 'resque/scheduler/tasks'
+      end
+    end
+  end
+end

data/lib/resque/scheduler/server/views/search_form.erb

@@ -1,4 +1,6 @@
 <form method="POST" action="<%= u 'delayed/search' %>">
+  <input type='checkbox' id='search_args' name='search_args' value="checked" <%= 'checked' if params[:search_args] == 'checked' %>/>
+  <label for="search_args"> Search Args?</label><br>
   <input type='input' name='search' value="<%= h params[:search] %>"/>
   <input type='submit' value='Search'/>
 </form>

data/lib/resque/scheduler/server.rb

@@ -48,7 +48,7 @@ module Resque
           if @parameters
             erb scheduler_template('requeue-params')
           else
-            Resque::Scheduler.enqueue_from_config(config)
+            Resque::Scheduler.enqueue_from_config(config, :recurring)
             redirect u('/overview')
           end
         end
@@ -68,7 +68,7 @@ module Resque
 
           # Insert the args hash into config and queue the resque job
           config = config.merge('args' => config_args)
-          Resque::Scheduler.enqueue_from_config(config)
+          Resque::Scheduler.enqueue_from_config(config, :recurring)
           redirect u('/overview')
         end
 
@@ -99,7 +99,8 @@ module Resque
         end
 
         def delayed_search
-          @jobs = find_job(params[:search])
+          field = params[:search_args] == 'checked' ? 'args' : 'class'
+          @jobs = find_job(params[:search], field)
           erb scheduler_template('search')
         end
 
@@ -153,21 +154,21 @@ module Resque
           )
         end
 
-        def find_job(worker)
-          worker = worker.downcase
-          results = working_jobs_for_worker(worker)
+        def find_job(term, field = 'class')
+          term = term.downcase
+          matches = ->(job) { job[field].to_s.downcase.include?(term) }
+          results = working_jobs_matching(matches)
 
-          dels = delayed_jobs_for_worker(worker)
+          dels = delayed_jobs_for_worker(term)
           results += dels.select do |j|
-            j['class'].downcase.include?(worker) &&
-              j.merge!('where_at' => 'delayed')
+            matches.call(j) && j.merge!('where_at' => 'delayed')
           end
 
           Resque.queues.each do |queue|
             queued = Resque.peek(queue, 0, Resque.size(queue))
             queued = [queued] unless queued.is_a?(Array)
             results += queued.select do |j|
-              j['class'].downcase.include?(worker) &&
+              matches.call(j) &&
                 j.merge!('queue' => queue, 'where_at' => 'queued')
             end
           end
@@ -187,13 +188,13 @@ module Resque
 
         def schedule_interval_every(every)
           every = [*every]
-          s = 'every: ' << every.first
+          s = 'every: ' << "#{every.first}#{'s' if every.first.is_a?(Numeric)}"
 
           return s unless every.length > 1
 
           s << ' ('
           meta = every.last.map do |key, value|
-            "#{key.to_s.tr('_', ' ')} #{value}"
+            "#{key.to_s.tr('_', ' ')} #{value}#{'s' if value.is_a?(Numeric)}"
           end
           s << meta.join(', ') << ')'
         end
@@ -228,12 +229,11 @@ module Resque
 
         private
 
-        def working_jobs_for_worker(worker)
+        def working_jobs_matching(matches)
           [].tap do |results|
             working = [*Resque.working]
             work = working.select do |w|
-              w.job && w.job['payload'] &&
-                w.job['payload']['class'].downcase.include?(worker)
+              w.job && w.job['payload'] && matches.call(w.job['payload'])
             end
             work.each do |w|
               results += [

data/lib/resque/scheduler/util.rb

@@ -34,6 +34,11 @@ module Resque
       def self.classify(dashed_word)
         dashed_word.split('-').map(&:capitalize).join
       end
+
+      def self.active_job_class?(klass)
+        defined?(::ActiveJob::Base) && klass.is_a?(Class) &&
+          klass < ::ActiveJob::Base
+      end
     end
   end
 end

data/lib/resque/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Resque
   module Scheduler
-    VERSION = '5.0.1'.freeze
+    VERSION = '5.1.1'.freeze
   end
 end

data/lib/resque/scheduler.rb

@@ -8,6 +8,8 @@ require_relative 'scheduler/logger_builder'
 require_relative 'scheduler/signal_handling'
 require_relative 'scheduler/failure_handler'
 
+require 'resque/scheduler/railtie' if defined?(Rails::Railtie)
+
 module Resque
   module Scheduler
     autoload :Cli, 'resque/scheduler/cli'
@@ -151,7 +153,7 @@ module Resque
           interval_defined = false
           interval_types = %w(cron every)
           interval_types.each do |interval_type|
-            next unless !config[interval_type].nil? && !config[interval_type].empty?
+            next unless !config[interval_type].nil? && !config[interval_type].to_s.empty?
             args = optionizate_interval_value(config[interval_type])
             args = [args, nil, job: true] if args.is_a?(::String)
 
@@ -196,7 +198,7 @@ module Resque
       # at_time - Time to start scheduling items (default: now).
       def handle_delayed_items(at_time = nil)
         timestamp = Resque.next_delayed_timestamp(at_time)
-        if timestamp
+        if timestamp && am_master
           procline 'Processing Delayed Items'
           until timestamp.nil?
             enqueue_delayed_items_for_timestamp(timestamp)
@@ -210,40 +212,48 @@ module Resque
 
         if item
           log "queuing #{item['class']} [delayed]"
-          enqueue(item)
+          enqueue(item, :delayed)
         end
 
         item
       end
 
+      def batch_delayed_items?
+        !disable_delayed_requeue_batches && delayed_requeue_batch_size > 1
+      end
+
       # Enqueues all delayed jobs for a timestamp
       def enqueue_delayed_items_for_timestamp(timestamp)
         count = 0
-        batch_size = delayed_requeue_batch_size
-        actual_batch_size = nil
+        batch_size = batch_delayed_items? ? delayed_requeue_batch_size : 1
 
-        log "Processing delayed items for timestamp #{timestamp}, in batches of #{batch_size}"
+        message = "Processing delayed items for timestamp #{timestamp}"
+        message += ", in batches of #{batch_size}" if batch_delayed_items?
+        log message
 
         loop do
+          actual_batch_size = 0
+
           handle_shutdown do
-            # Continually check that it is still the master
             if am_master
-              actual_batch_size = enqueue_items_in_batch_for_timestamp(timestamp,
-                                                                       batch_size)
+              if batch_delayed_items?
+                actual_batch_size = enqueue_items_in_batch_for_timestamp(timestamp, batch_size)
+                log "queued batch of #{actual_batch_size} jobs"
+              else
+                item = enqueue_next_item(timestamp)
+                actual_batch_size = item.nil? ? 0 : 1
+              end
             end
           end
 
           count += actual_batch_size
-          log "queued #{count} jobs" if actual_batch_size != -1
 
           # continue processing until there are no more items in this
           # timestamp. If we don't have a full batch, this is the last one.
-          # This also breaks us in the event of a redis transaction failure
-          # i.e. enqueue_items_in_batch_for_timestamp returned -1
           break if actual_batch_size < batch_size
         end
 
-        log "finished queueing #{count} total jobs for timestamp #{timestamp}" if count != -1
+        log "finished queueing #{count} total jobs for timestamp #{timestamp}" if count > 0
       end
 
       def timestamp_key(timestamp)
@@ -253,49 +263,40 @@ module Resque
       def enqueue_items_in_batch_for_timestamp(timestamp, batch_size)
         timestamp_bucket_key = timestamp_key(timestamp)
 
-        encoded_jobs_to_requeue = Resque.redis.lrange(timestamp_bucket_key, 0, batch_size - 1)
-
-        # Watch is used to ensure that the timestamp bucket we are operating on
-        # is not altered by any other clients between the watch call and when we call exec
-        # (to execute the multi block). We should error catch on the redis.exec return value
-        # as that will indicate if the entire transaction was aborted or not. Though we should
-        # be safe as our ltrim is inside the multi block and therefore also would have been
-        # aborted. So nothing would have been queued, but also nothing lost from the bucket.
-        watch_result = Resque.redis.watch(timestamp_bucket_key) do
-          Resque.redis.multi do |pipeline|
-            encoded_jobs_to_requeue.each do |encoded_job|
-              pipeline.srem("timestamps:#{encoded_job}", timestamp_bucket_key)
-
-              decoded_job = Resque.decode(encoded_job)
-              enqueue(decoded_job)
-            end
+        return 0 unless (encoded_jobs = take_delayed_batch(timestamp_bucket_key, batch_size))
 
-            pipeline.ltrim(timestamp_bucket_key, batch_size, -1)
-          end
+        encoded_jobs.each do |encoded_job|
+          enqueue(Resque.decode(encoded_job), :delayed)
         end
 
-        # Did the multi block successfully remove from this timestamp and enqueue the jobs?
-        success = !watch_result.nil?
-
-        # If this was the last batch in this timestamp bucket, clean up
-        if success && encoded_jobs_to_requeue.count < batch_size
+        if encoded_jobs.count < batch_size
           Resque.clean_up_timestamp(timestamp_bucket_key, timestamp)
         end
 
-        unless success
-          # Our batched transaction failed in Redis due to the timestamp_bucket_key value
-          # being modified while we built our multi block. We return -1 to ensure we break
-          # out of the loop iterating on this timestamp so it can be re-processed via the
-          # loop in handle_delayed_items.
-          return -1
-        end
+        encoded_jobs.count
+      end
+
+      # Returns nil if the timestamp bucket changed before the batch was taken.
+      def take_delayed_batch(timestamp_bucket_key, batch_size)
+        Resque.redis.watch(timestamp_bucket_key) do
+          encoded_jobs = Resque.redis.lrange(timestamp_bucket_key, 0, batch_size - 1)
+          taken = Resque.redis.multi do |transaction|
+            encoded_jobs.each do |encoded_job|
+              transaction.srem("timestamps:#{encoded_job}", [timestamp_bucket_key])
+            end
+            transaction.ltrim(timestamp_bucket_key, batch_size, -1)
+          end
 
-        # will return 0 if none were left to batch
-        encoded_jobs_to_requeue.count
+          encoded_jobs if taken
+        end
       end
 
-      def enqueue(config)
-        enqueue_from_config(config)
+      # Enqueues a job like enqueue_from_config, but hands errors to the failure
+      # handler instead of raising them. Pass :delayed as hooks for a job that
+      # left the delayed queue or :recurring for a schedule entry to run the
+      # matching hooks.
+      def enqueue(config, hooks = nil)
+        enqueue_from_config(config, hooks)
       rescue => e
         Resque::Scheduler.failure_handler.on_enqueue_failure(config, e)
       end
@@ -306,8 +307,11 @@ module Resque
         exit if @shutdown
       end
 
-      # Enqueues a job based on a config hash
-      def enqueue_from_config(job_config)
+      # Enqueues a job based on a config hash. Pass :delayed as hooks for a job
+      # that left the delayed queue or :recurring for a schedule entry to run
+      # the matching hooks.
+      def enqueue_from_config(job_config, hooks = nil)
+        Resque::Scheduler::Plugin.validate_enqueue_hooks(hooks)
         args = job_config['args'] || job_config[:args]
 
         klass_name = job_config['class'] || job_config[:class]
@@ -318,9 +322,13 @@ module Resque
         end
 
         params = args.is_a?(Hash) ? [args] : Array(args)
-        queue = job_config['queue'] ||
-                job_config[:queue] ||
-                Resque.queue_from_class(klass)
+        queue = job_config['queue'] || job_config[:queue]
+
+        if Resque::Scheduler::Util.active_job_class?(klass)
+          return klass.set(**{ queue: queue }.compact).perform_later(*params)
+        end
+
+        queue ||= Resque.queue_from_class(klass)
         # Support custom job classes like those that inherit from
         # Resque::JobWithStatus (resque-status)
         job_klass = job_config['custom_job_class']
@@ -343,8 +351,7 @@ module Resque
           # for non-existent classes (for example: running scheduler in
           # one app that schedules for another.
           if Class === klass
-            Resque::Scheduler::Plugin.process_schedule_hooks(klass, *params) do
-              Resque::Scheduler::Plugin.run_before_delayed_enqueue_hooks(klass, *params)
+            Resque::Scheduler::Plugin.process_enqueue_hooks(hooks, klass, *params) do
               # If the class is a custom job class, call self#scheduled on it.
               # This allows you to do things like Resque.enqueue_at(timestamp,
               # CustomJobClass). Otherwise, pass off to Resque.
@@ -504,7 +511,7 @@ module Resque
       def enqueue_recurring(name, config)
         if am_master
           log! "queueing #{config['class']} (#{name})"
-          enqueue(config)
+          enqueue(config, :recurring)
           Resque.last_enqueued_at(name, Time.now.to_s)
         end
       end

data/resque-scheduler.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.license = 'MIT'
   spec.metadata['rubygems_mfa_required'] = 'true'
 
-  spec.required_ruby_version = '>= 3.0.0'
+  spec.required_ruby_version = '>= 3.2.0'
 
   spec.files = `git ls-files -z`.split("\0").reject do |f|
     f.match(%r{^(test|spec|features|examples|bin|tasks)/}) ||
@@ -43,6 +43,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = %w(lib)
 
+  spec.add_development_dependency 'activejob'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'json'
   spec.add_development_dependency 'irb'
@@ -51,6 +52,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'ostruct'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'railties'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'test-unit'
@@ -59,14 +61,12 @@ Gem::Specification.new do |spec|
 
   # We pin rubocop because new cops have a tendency to result in false-y
   # positives for new contributors, which is not a nice experience.
-  spec.add_development_dependency 'rubocop', '~> 0.80'
+  spec.add_development_dependency 'rubocop', '~> 1.91'
 
   spec.add_runtime_dependency 'base64', '~> 0.1'
   spec.add_runtime_dependency 'logger'
   spec.add_runtime_dependency 'mono_logger', '~> 1.0'
   spec.add_runtime_dependency 'redis', '>= 4.0'
   spec.add_runtime_dependency 'resque', '>= 3.0'
-  # rufus-scheduler v3.7 causes a failure in test/multi_process_test.rb
-  # rufus-scheduler v3.3 is missing a to_local method which fails tests
-  spec.add_runtime_dependency 'rufus-scheduler', '~> 3.2', '!= 3.3'
+  spec.add_runtime_dependency 'rufus-scheduler', '~> 3.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-scheduler
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.1.1
 platform: ruby
 authors:
 - Ben VandenBos
@@ -14,6 +14,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +140,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -202,14 +230,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.80'
+        version: '1.91'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.80'
+        version: '1.91'
 - !ruby/object:Gem::Dependency
   name: base64
   requirement: !ruby/object:Gem::Requirement
@@ -286,20 +314,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '3.9'
 description: |2
       Light weight job scheduling on top of Resque.
       Adds methods enqueue_at/enqueue_in to schedule jobs in the future.
@@ -321,8 +343,6 @@ files:
 - ".devcontainer/devcontainer.json"
 - ".devcontainer/docker-compose.yml"
 - ".github/dependabot.yml"
-- ".github/workflows/codeql-analysis.yml"
-- ".github/workflows/rubocop.yml"
 - ".github/workflows/ruby.yml"
 - AUTHORS.md
 - CHANGELOG.md
@@ -348,6 +368,7 @@ files:
 - lib/resque/scheduler/locking.rb
 - lib/resque/scheduler/logger_builder.rb
 - lib/resque/scheduler/plugin.rb
+- lib/resque/scheduler/railtie.rb
 - lib/resque/scheduler/scheduling_extensions.rb
 - lib/resque/scheduler/server.rb
 - lib/resque/scheduler/server/views/delayed.erb
@@ -374,7 +395,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.github/workflows/codeql-analysis.yml

@@ -1,59 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master, '*-stable' ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
-  schedule:
-    - cron: '44 16 * * 6'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'ruby' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://git.io/codeql-language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3

data/.github/workflows/rubocop.yml

@@ -1,27 +0,0 @@
-name: Rubocop
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-
-jobs:
-  rubocop:
-    name: Rubocop
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        ruby: [
-            3.4
-        ]
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-      - name: Ruby linter
-        run: bundle exec rubocop