mini_scheduler 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4a38d3c8bcf38814218e73edefc423c504c8469b3c9e3c05a08bb6b0012dd47
-  data.tar.gz: 13a72f979b4007dd48910a5b03efafab049643e2944058be2a01602855e87393
+  metadata.gz: '08b8517cbb1f57938ca8337f54bd804e402d176070934398dfd53ab1b00b5b2f'
+  data.tar.gz: 2d70f148236b793e71d276e5acd72403d4945a23d33f36121f081ec7b2ee3f0e
 SHA512:
-  metadata.gz: d748b674b67d3faf5e1507d5b51d2dfaa1585cf9315d93f8b634faaaf9d2942667f17b345ace2375cfa452412ddb59aac67ed98bb704de831f924f9f4545b700
-  data.tar.gz: 0cae809fb72df9043374a451cfa8e906e434a460201e3383bd54c60c2e4acc92147a83af8887377f3ba42bd661b104a9b7f1e500a80a1c249683fb72f406dbca
+  metadata.gz: fa584d657e08dfbcfd0f0f7dc05d7da2b4884423a7140afbeedf8381b5dc475823c312e0c08e0ecf0a7461fc0c6cc36f39e19df0d4a80d35b03135431d300a64
+  data.tar.gz: a1c34182f330304932e95a94c75a9366444be9bbedf88fc41cb3c8d359de13d5f1bdda957966b1399b66d96e901dcc165f34d5f456f6e521e070ac539ea5f107

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.17.0 - 2024-08-06
+
+- Add `MiniScheduler::Manager.discover_running_scheduled_jobs` API to allow running scheduled jobs to easily be discovered on the
+  current host.
+
 # 0.16.0 - 2023-05-17
 
 - Support Redis gem version 5
@@ -14,7 +19,7 @@
 # 0.13.0 - 2020-11-30
 
 - Fix exception code so it has parity with Sidekiq 4.2.3 and up, version bump cause
-minimum version of Sikekiq changed.
+  minimum version of Sikekiq changed.
 
 # 0.12.3 - 2020-10-15
 
@@ -35,7 +40,7 @@ minimum version of Sikekiq changed.
 # 0.11.0 - 2019-06-24
 
 - Correct situation where distributed mutex could end in a tight loop when
- redis could not be contacted
+  redis could not be contacted
 
 # 0.9.2 - 2019-04-26
 

data/Gemfile

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec

data/app/models/mini_scheduler/stat.rb

@@ -3,11 +3,10 @@
 if defined?(ActiveRecord::Base)
   module MiniScheduler
     class Stat < ActiveRecord::Base
-
-      self.table_name = 'scheduler_stats'
+      self.table_name = "scheduler_stats"
 
       def self.purge_old
-        where('started_at < ?', 1.months.ago).delete_all
+        where("started_at < ?", 1.months.ago).delete_all
       end
     end
   end

data/lib/generators/mini_scheduler/install/install_generator.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'rails/generators'
-require 'rails/generators/migration'
-require 'active_record'
+require "rails/generators"
+require "rails/generators/migration"
+require "active_record"
 
 module MiniScheduler
   module Generators
     class InstallGenerator < ::Rails::Generators::Base
       include Rails::Generators::Migration
-      source_root File.expand_path('../templates', __FILE__)
+      source_root File.expand_path("../templates", __FILE__)
       desc "Generate files for MiniScheduler"
 
       def self.next_migration_number(path)
@@ -17,7 +17,10 @@ module MiniScheduler
       end
 
       def copy_migrations
-        migration_template("create_mini_scheduler_stats.rb", "db/migrate/create_mini_scheduler_stats.rb")
+        migration_template(
+          "create_mini_scheduler_stats.rb",
+          "db/migrate/create_mini_scheduler_stats.rb",
+        )
       end
 
       def copy_initializer_file

data/lib/generators/mini_scheduler/install/templates/mini_scheduler_initializer.rb

@@ -38,7 +38,5 @@ MiniScheduler.configure do |config|
 end
 
 if Sidekiq.server? && defined?(Rails)
-  Rails.application.config.after_initialize do
-    MiniScheduler.start
-  end
+  Rails.application.config.after_initialize { MiniScheduler.start }
 end

data/lib/mini_scheduler/distributed_mutex.rb

@@ -2,7 +2,8 @@
 
 module MiniScheduler
   class DistributedMutex
-    class Timeout < StandardError; end
+    class Timeout < StandardError
+    end
 
     @default_redis = nil
 
@@ -15,7 +16,7 @@ module MiniScheduler
     end
 
     def initialize(key, redis)
-      raise ArgumentError.new('redis argument is nil') if redis.nil?
+      raise ArgumentError.new("redis argument is nil") if redis.nil?
       @key = key
       @redis = redis
       @mutex = Mutex.new
@@ -32,7 +33,6 @@ module MiniScheduler
       attempts = 0
       sleep_duration = BASE_SLEEP_DURATION
       while !try_to_get_lock
-
         sleep(sleep_duration)
 
         if sleep_duration < MAX_SLEEP_DURATION
@@ -44,7 +44,6 @@ module MiniScheduler
       end
 
       yield
-
     ensure
       @redis.del @key
       @mutex.unlock
@@ -62,9 +61,7 @@ module MiniScheduler
           @redis.watch @key
           time = @redis.get @key
           if time && time.to_i < Time.now.to_i
-            got_lock = @redis.multi do
-              @redis.set @key, Time.now.to_i + 60
-            end
+            got_lock = @redis.multi { @redis.set @key, Time.now.to_i + 60 }
           end
         ensure
           @redis.unwatch
@@ -73,7 +70,5 @@ module MiniScheduler
 
       got_lock
     end
-
   end
-
 end

data/lib/mini_scheduler/manager.rb

@@ -12,25 +12,27 @@ module MiniScheduler
         @manager = manager
         @hostname = manager.hostname
 
-        @recovery_thread = Thread.new do
-          while !@stopped
-            sleep 60
-
-            @mutex.synchronize do
-              repair_queue
-              reschedule_orphans
-              ensure_worker_threads
+        @recovery_thread =
+          Thread.new do
+            while !@stopped
+              sleep 60
+
+              @mutex.synchronize do
+                repair_queue
+                reschedule_orphans
+                ensure_worker_threads
+              end
             end
           end
-        end
-        @keep_alive_thread = Thread.new do
-          while !@stopped
-            @mutex.synchronize do
-              keep_alive
+
+        @keep_alive_thread =
+          Thread.new do
+            while !@stopped
+              @mutex.synchronize { keep_alive }
+              sleep(@manager.keep_alive_duration / 2)
             end
-            sleep (@manager.keep_alive_duration / 2)
           end
-        end
+
         ensure_worker_threads
       end
 
@@ -49,27 +51,36 @@ module MiniScheduler
       def reschedule_orphans
         @manager.reschedule_orphans!
       rescue => ex
-        MiniScheduler.handle_job_exception(ex, message: "Error during MiniScheduler reschedule_orphans")
+        MiniScheduler.handle_job_exception(
+          ex,
+          message: "Error during MiniScheduler reschedule_orphans",
+        )
       end
 
       def ensure_worker_threads
         @threads ||= []
         @threads.delete_if { |t| !t.alive? }
-        (@manager.workers - @threads.size).times do
-          @threads << Thread.new { worker_loop }
-        end
+        (@manager.workers - @threads.size).times { @threads << Thread.new { worker_loop } }
       rescue => ex
-        MiniScheduler.handle_job_exception(ex, message: "Error during MiniScheduler ensure_worker_threads")
+        MiniScheduler.handle_job_exception(
+          ex,
+          message: "Error during MiniScheduler ensure_worker_threads",
+        )
       end
 
       def worker_loop
         set_current_worker_thread_id!
         keep_alive(current_worker_thread_id)
+
         while !@stopped
           begin
             process_queue
           rescue => ex
-            MiniScheduler.handle_job_exception(ex, message: "Error during MiniScheduler worker_loop")
+            MiniScheduler.handle_job_exception(
+              ex,
+              message: "Error during MiniScheduler worker_loop",
+            )
+
             break # Data could be in a bad state - stop the thread
           end
         end
@@ -84,7 +95,9 @@ module MiniScheduler
       end
 
       def set_current_worker_thread_id!
-        Thread.current[:mini_scheduler_worker_thread_id] = "#{@manager.identity_key}:thread_#{SecureRandom.alphanumeric(10)}"
+        Thread.current[
+          :mini_scheduler_worker_thread_id
+        ] = "#{@manager.identity_key}:thread_#{SecureRandom.alphanumeric(10)}"
       end
 
       def worker_thread_ids
@@ -93,6 +106,7 @@ module MiniScheduler
 
       def process_queue
         klass = @queue.deq
+
         # hack alert, I need to both deq and set @running atomically.
         @running = true
 
@@ -110,22 +124,30 @@ module MiniScheduler
           @mutex.synchronize { info.write! }
 
           if @manager.enable_stats
-            stat = MiniScheduler::Stat.create!(
-              name: klass.to_s,
-              hostname: hostname,
-              pid: Process.pid,
-              started_at: Time.now,
-              live_slots_start: GC.stat[:heap_live_slots]
-            )
+            stat =
+              MiniScheduler::Stat.create!(
+                name: klass.to_s,
+                hostname: hostname,
+                pid: Process.pid,
+                started_at: Time.now,
+                live_slots_start: GC.stat[:heap_live_slots],
+              )
           end
 
           klass.new.perform
         rescue => e
-          MiniScheduler.handle_job_exception(e, message: "Error while running a scheduled job", job: { "class" => klass })
+          MiniScheduler.handle_job_exception(
+            e,
+            message: "Error while running a scheduled job",
+            job: {
+              "class" => klass,
+            },
+          )
 
           error = "#{e.class}: #{e.message} #{e.backtrace.join("\n")}"
           failed = true
         end
+
         duration = ((Time.now.to_f - start) * 1000).to_i
         info.prev_duration = duration
         info.prev_result = failed ? "FAILED" : "OK"
@@ -135,15 +157,14 @@ module MiniScheduler
             duration_ms: duration,
             live_slots_finish: GC.stat[:heap_live_slots],
             success: !failed,
-            error: error
+            error: error,
           )
           MiniScheduler.job_ran&.call(stat)
         end
-        attempts(3) do
-          @mutex.synchronize { info.write! }
-        end
+        attempts(3) { @mutex.synchronize { info.write! } }
       ensure
         @running = false
+
         if defined?(ActiveRecord::Base)
           ActiveRecord::Base.connection_handler.clear_active_connections!
         end
@@ -163,10 +184,11 @@ module MiniScheduler
 
           enq(nil)
 
-          kill_thread = Thread.new do
-            sleep 0.5
-            @threads.each(&:kill)
-          end
+          kill_thread =
+            Thread.new do
+              sleep 0.5
+              @threads.each(&:kill)
+            end
 
           @threads.each(&:join)
           kill_thread.kill
@@ -179,29 +201,24 @@ module MiniScheduler
       end
 
       def wait_till_done
-        while !@queue.empty? && !(@queue.num_waiting > 0)
-          sleep 0.001
-        end
+        sleep 0.001 while !@queue.empty? && !(@queue.num_waiting > 0)
         # this is a hack, but is only used for test anyway
         # if tests fail that depend on this we are forced to increase it.
         sleep 0.010
-        while @running
-          sleep 0.001
-        end
+        sleep 0.001 while @running
       end
 
       def attempts(max_attempts)
         attempt = 0
         begin
           yield
-        rescue
+        rescue StandardError
           attempt += 1
           raise if attempt >= max_attempts
           sleep Random.rand
           retry
         end
       end
-
     end
 
     def self.without_runner
@@ -233,11 +250,7 @@ module MiniScheduler
     end
 
     def hostname
-      @hostname ||= begin
-                      `hostname`.strip
-                    rescue
-                      "unknown"
-                    end
+      @hostname ||= self.class.hostname
     end
 
     def schedule_info(klass)
@@ -249,15 +262,11 @@ module MiniScheduler
     end
 
     def ensure_schedule!(klass)
-      lock do
-        schedule_info(klass).schedule!
-      end
+      lock { schedule_info(klass).schedule! }
     end
 
     def remove(klass)
-      lock do
-        schedule_info(klass).del!
-      end
+      lock { schedule_info(klass).del! }
     end
 
     def reschedule_orphans!
@@ -268,18 +277,20 @@ module MiniScheduler
     end
 
     def reschedule_orphans_on!(hostname = nil)
-      redis.zrange(Manager.queue_key(queue, hostname), 0, -1).each do |key|
-        klass = get_klass(key)
-        next unless klass
-        info = schedule_info(klass)
-
-        if ['QUEUED', 'RUNNING'].include?(info.prev_result) &&
-          (info.current_owner.blank? || !redis.get(info.current_owner))
-          info.prev_result = 'ORPHAN'
-          info.next_run = Time.now.to_i
-          info.write!
+      redis
+        .zrange(Manager.queue_key(queue, hostname), 0, -1)
+        .each do |key|
+          klass = get_klass(key)
+          next unless klass
+          info = schedule_info(klass)
+
+          if %w[QUEUED RUNNING].include?(info.prev_result) &&
+               (!info.current_owner || !redis.get(info.current_owner))
+            info.prev_result = "ORPHAN"
+            info.next_run = Time.now.to_i
+            info.write!
+          end
         end
-      end
     end
 
     def get_klass(name)
@@ -289,10 +300,14 @@ module MiniScheduler
     end
 
     def repair_queue
-      return if redis.exists?(self.class.queue_key(queue)) ||
-        redis.exists?(self.class.queue_key(queue, hostname))
+      if redis.exists?(self.class.queue_key(queue)) ||
+           redis.exists?(self.class.queue_key(queue, hostname))
+        return
+      end
 
-      self.class.discover_schedules
+      self
+        .class
+        .discover_schedules
         .select { |schedule| schedule.queue == queue }
         .each { |schedule| ensure_schedule!(schedule) }
     end
@@ -310,9 +325,7 @@ module MiniScheduler
 
       if due.to_i <= Time.now.to_i
         klass = get_klass(key)
-        if !klass || (
-          (klass.is_per_host && !hostname) || (hostname && !klass.is_per_host)
-        )
+        if !klass || ((klass.is_per_host && !hostname) || (hostname && !klass.is_per_host))
           # corrupt key, nuke it (renamed job or something)
           redis.zrem Manager.queue_key(queue, hostname), key
           return
@@ -345,9 +358,7 @@ module MiniScheduler
 
     def keep_alive(*ids)
       ids = [identity_key, *@runner.worker_thread_ids] if ids.size == 0
-      ids.each do |identity_key|
-        redis.setex identity_key, keep_alive_duration, ""
-      end
+      ids.each { |identity_key| redis.setex identity_key, keep_alive_duration, "" }
     end
 
     def lock
@@ -357,7 +368,9 @@ module MiniScheduler
     end
 
     def self.discover_queues
-      ObjectSpace.each_object(MiniScheduler::Schedule).map(&:queue).to_set
+      queues = Set.new
+      ObjectSpace.each_object(MiniScheduler::Schedule).each { |schedule| queues << schedule.queue }
+      queues
     end
 
     def self.discover_schedules
@@ -376,6 +389,73 @@ module MiniScheduler
       schedules
     end
 
+    def self.hostname
+      @hostname ||=
+        begin
+          require "socket"
+          Socket.gethostname
+        rescue => e
+          begin
+            `hostname`.strip
+          rescue => e
+            "unknown_host"
+          end
+        end
+    end
+
+    # Discover running scheduled jobs on the current host.
+    #
+    # @example
+    #
+    #   MiniScheduler::Manager.discover_running_scheduled_jobs
+    #
+    # @return [Array<Hash>] an array of hashes representing the running scheduled jobs.
+    # @option job [Class] :class The class of the scheduled job.
+    # @option job [Time] :started_at The time when the scheduled job started.
+    # @option job [String] :thread_id The ID of the worker thread running the job.
+    #   The thread can be identified by matching the `:mini_scheduler_worker_thread_id` thread variable with the ID.
+    def self.discover_running_scheduled_jobs
+      hostname = self.hostname
+
+      schedule_keys =
+        discover_schedules.reduce({}) do |acc, klass|
+          acc[klass] = if klass.is_per_host
+            self.schedule_key(klass, hostname)
+          else
+            self.schedule_key(klass)
+          end
+
+          acc
+        end
+
+      running_scheduled_jobs = []
+
+      schedule_keys
+        .keys
+        .zip(MiniScheduler.redis.mget(*schedule_keys.values))
+        .each do |scheduled_job_class, scheduled_job_info|
+          next if scheduled_job_info.nil?
+
+          parsed =
+            begin
+              JSON.parse(scheduled_job_info, symbolize_names: true)
+            rescue JSON::ParserError
+              nil
+            end
+
+          next if parsed.nil?
+          next if parsed[:prev_result] != "RUNNING"
+
+          running_scheduled_jobs << {
+            class: scheduled_job_class,
+            started_at: Time.at(parsed[:prev_run]),
+            thread_id: parsed[:current_owner],
+          }
+        end
+
+      running_scheduled_jobs
+    end
+
     @class_mutex = Mutex.new
     def self.seq
       @class_mutex.synchronize do
@@ -388,7 +468,8 @@ module MiniScheduler
     def identity_key
       return @identity_key if @identity_key
       @@identity_key_mutex.synchronize do
-        @identity_key ||= "_scheduler_#{hostname}:#{Process.pid}:#{self.class.seq}:#{SecureRandom.hex}"
+        @identity_key ||=
+          "_scheduler_#{hostname}:#{Process.pid}:#{self.class.seq}:#{SecureRandom.hex}"
       end
     end
 
@@ -397,19 +478,11 @@ module MiniScheduler
     end
 
     def self.queue_key(queue, hostname = nil)
-      if hostname
-        "_scheduler_queue_#{queue}_#{hostname}_"
-      else
-        "_scheduler_queue_#{queue}_"
-      end
+      hostname ? "_scheduler_queue_#{queue}_#{hostname}_" : "_scheduler_queue_#{queue}_"
     end
 
     def self.schedule_key(klass, hostname = nil)
-      if hostname
-        "_scheduler_#{klass}_#{hostname}"
-      else
-        "_scheduler_#{klass}"
-      end
+      hostname ? "_scheduler_#{klass}_#{hostname}" : "_scheduler_#{klass}"
     end
   end
 end

data/lib/mini_scheduler/schedule.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
 module MiniScheduler::Schedule
-
   def queue(value = nil)
     @queue = value.to_s if value
     @queue ||= "default"
   end
 
   def daily(options = nil)
-    if options
-      @daily = options
-    end
+    @daily = options if options
     @daily
   end
 

data/lib/mini_scheduler/schedule_info.rb

@@ -2,11 +2,7 @@
 
 module MiniScheduler
   class ScheduleInfo
-    attr_accessor :next_run,
-                  :prev_run,
-                  :prev_duration,
-                  :prev_result,
-                  :current_owner
+    attr_accessor :next_run, :prev_run, :prev_duration, :prev_result, :current_owner
 
     def initialize(klass, manager)
       @klass = klass
@@ -25,7 +21,7 @@ module MiniScheduler
         @prev_duration = data["prev_duration"]
         @current_owner = data["current_owner"]
       end
-    rescue
+    rescue StandardError
       # corrupt redis
       @next_run = @prev_run = @prev_result = @prev_duration = @current_owner = nil
     end
@@ -40,17 +36,14 @@ module MiniScheduler
 
     def valid_every?
       return false unless @klass.every
-      !!@prev_run &&
-        @prev_run <= Time.now.to_i &&
+      !!@prev_run && @prev_run <= Time.now.to_i &&
         @next_run < @prev_run + @klass.every * (1 + @manager.random_ratio)
     end
 
     def valid_daily?
       return false unless @klass.daily
       return true if !@prev_run && @next_run && @next_run <= (Time.now + 1.day).to_i
-      !!@prev_run &&
-        @prev_run <= Time.now.to_i &&
-        @next_run < @prev_run + 1.day
+      !!@prev_run && @prev_run <= Time.now.to_i && @next_run < @prev_run + 1.day
     end
 
     def schedule_every!
@@ -63,9 +56,7 @@ module MiniScheduler
       # this can look a bit confusing, but @next_run above could be off
       # if prev_run is off, so this ensures it ends up correct and in the
       # future
-      if !valid?
-        @next_run = Time.now.to_i + 300 * Random.rand
-      end
+      @next_run = Time.now.to_i + 300 * Random.rand if !valid?
     end
 
     def schedule_daily!
@@ -96,13 +87,14 @@ module MiniScheduler
 
     def write!
       clear!
-      redis.set key, {
-        next_run: @next_run,
-        prev_run: @prev_run,
-        prev_duration: @prev_duration,
-        prev_result: @prev_result,
-        current_owner: @current_owner
-      }.to_json
+      redis.set key,
+                {
+                  next_run: @next_run,
+                  prev_run: @prev_run,
+                  prev_duration: @prev_duration,
+                  prev_result: @prev_result,
+                  current_owner: @current_owner,
+                }.to_json
 
       redis.zadd queue_key, @next_run.to_s, @klass.to_s if @next_run
     end
@@ -133,10 +125,10 @@ module MiniScheduler
     end
 
     private
+
     def clear!
       redis.del key
       redis.zrem queue_key, @klass.to_s
     end
-
   end
 end

data/lib/mini_scheduler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniScheduler
-  VERSION = "0.16.0"
+  VERSION = "0.17.0"
 end

data/lib/mini_scheduler/web.rb

@@ -2,7 +2,7 @@
 # Based off sidetiq https://github.com/tobiassvn/sidetiq/blob/master/lib/sidetiq/web.rb
 module MiniScheduler
   module Web
-    VIEWS = File.expand_path('views', File.dirname(__FILE__)) unless defined? VIEWS
+    VIEWS = File.expand_path("views", File.dirname(__FILE__)) unless defined?(VIEWS)
 
     def self.find_schedules_by_time
       Manager.discover_schedules.sort do |a, b|
@@ -19,7 +19,6 @@ module MiniScheduler
     end
 
     def self.registered(app)
-
       app.helpers do
         def sane_time(time)
           return unless time
@@ -31,7 +30,7 @@ module MiniScheduler
           if duration < 1000
             "#{duration}ms"
           else
-            "#{'%.2f' % (duration / 1000.0)} secs"
+            "#{"%.2f" % (duration / 1000.0)} secs"
           end
         end
       end
@@ -39,24 +38,22 @@ module MiniScheduler
       app.get "/scheduler" do
         MiniScheduler.before_sidekiq_web_request&.call
         @schedules = Web.find_schedules_by_time
-        erb File.read(File.join(VIEWS, 'scheduler.erb')), locals: { view_path: VIEWS }
+        erb File.read(File.join(VIEWS, "scheduler.erb")), locals: { view_path: VIEWS }
       end
 
       app.get "/scheduler/history" do
         MiniScheduler.before_sidekiq_web_request&.call
         @schedules = Manager.discover_schedules
         @schedules.sort_by!(&:to_s)
-        @scheduler_stats = Stat.order('started_at desc')
+        @scheduler_stats = Stat.order("started_at desc")
 
         @filter = params[:filter]
         names = @schedules.map(&:to_s)
         @filter = nil if !names.include?(@filter)
-        if @filter
-          @scheduler_stats = @scheduler_stats.where(name: @filter)
-        end
+        @scheduler_stats = @scheduler_stats.where(name: @filter) if @filter
 
         @scheduler_stats = @scheduler_stats.limit(200)
-        erb File.read(File.join(VIEWS, 'history.erb')), locals: { view_path: VIEWS }
+        erb File.read(File.join(VIEWS, "history.erb")), locals: { view_path: VIEWS }
       end
 
       app.post "/scheduler/:name/trigger" do
@@ -71,7 +68,6 @@ module MiniScheduler
 
         redirect "#{root_path}scheduler"
       end
-
     end
   end
 end

data/lib/mini_scheduler.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 require "mini_scheduler/engine"
-require 'mini_scheduler/schedule'
-require 'mini_scheduler/schedule_info'
-require 'mini_scheduler/manager'
-require 'mini_scheduler/distributed_mutex'
-require 'sidekiq'
+require "mini_scheduler/schedule"
+require "mini_scheduler/schedule_info"
+require "mini_scheduler/manager"
+require "mini_scheduler/distributed_mutex"
+require "sidekiq"
 
 begin
-  require 'sidekiq/exception_handler'
+  require "sidekiq/exception_handler"
 rescue LoadError
 end
 
 module MiniScheduler
-
   def self.configure
     yield self
   end
@@ -69,18 +68,12 @@ module MiniScheduler
     Manager.discover_queues.each do |queue|
       manager = Manager.new(queue: queue, workers: workers)
 
-      schedules.each do |schedule|
-        if schedule.queue == queue
-          manager.ensure_schedule!(schedule)
-        end
-      end
+      schedules.each { |schedule| manager.ensure_schedule!(schedule) if schedule.queue == queue }
 
       Thread.new do
         while true
           begin
-            if !self.skip_schedule || !self.skip_schedule.call
-              manager.tick
-            end
+            manager.tick if !self.skip_schedule || !self.skip_schedule.call
           rescue => e
             # the show must go on
             handle_job_exception(e, message: "While ticking scheduling manager")

data/mini_scheduler.gemspec

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(lib) if !$LOAD_PATH.include?(lib)
 require "mini_scheduler/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "mini_scheduler"
-  spec.version       = MiniScheduler::VERSION
-  spec.authors       = ["Sam Saffron", "Neil Lalonde"]
-  spec.email         = ["neil.lalonde@discourse.org"]
+  spec.name = "mini_scheduler"
+  spec.version = MiniScheduler::VERSION
+  spec.authors = ["Sam Saffron", "Neil Lalonde"]
+  spec.email = ["neil.lalonde@discourse.org"]
 
-  spec.summary       = %q{Adds recurring jobs for Sidekiq}
-  spec.description   = %q{Adds recurring jobs for Sidekiq}
-  spec.homepage      = "https://github.com/discourse/mini_scheduler"
-  spec.license       = "MIT"
+  spec.summary = "Adds recurring jobs for Sidekiq"
+  spec.description = "Adds recurring jobs for Sidekiq"
+  spec.homepage = "https://github.com/discourse/mini_scheduler"
+  spec.license = "MIT"
 
   spec.required_ruby_version = ">= 2.7.0"
 
@@ -30,5 +30,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "guard-rspec", "~> 4.0"
   spec.add_development_dependency "redis", ">= 4.0"
   spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rubocop-discourse", "= 3.2.0"
+  spec.add_development_dependency "rubocop-discourse", "= 3.8.1"
+  spec.add_development_dependency "syntax_tree"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mini_scheduler
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Sam Saffron
 - Neil Lalonde
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-17 00:00:00.000000000 Z
+date: 2024-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -149,14 +149,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 3.8.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 3.8.1
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  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'
 description: Adds recurring jobs for Sidekiq
 email:
 - neil.lalonde@discourse.org
@@ -188,7 +202,7 @@ homepage: https://github.com/discourse/mini_scheduler
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -203,8 +217,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: Adds recurring jobs for Sidekiq
 test_files: []