sidekiq-unique-jobs 7.1.18 → 7.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fffa63d97388ac34a983ddeb04fc3d515bc263af1688884826496dfb53d7c10
-  data.tar.gz: 4ad0f841add9bf76ca2aa9064eee3dcd55d6cf8e7cbf4d225667edcb1d8ea81f
+  metadata.gz: a009df15de36d139adf211d9c4cd96fe42e8bdfd243831dc7d4f64bc4f98cd56
+  data.tar.gz: 767f9e88f3ca9fe563d34243ee98c1bc6dcb9852575b0e62153a66b213fef50a
 SHA512:
-  metadata.gz: 854f4bfc85b98bfa04951ff3b9d9276f9723a29d3e564df27e05b6f4321f2cad67adcf52cbc0501f1a247515bd23e358fbf4f9c6ba11c9072bb1bdef0cc97e8d
-  data.tar.gz: 956d56e8fc94184d02bf8b174534d11e6ddfcb48416f5bdf0df0be56474714bcb08d91ada0d41223eca1784db164842d3fa184ecd9b09689904f3f1e253ac7ed
+  metadata.gz: c5c4d0e50fea0faac52c9183db15db1121af9e2839996e5593b4404d1cc5d1c50bee60e574d2538149a5a5fbe2832296041524f175a42859d239b1b8fe049165
+  data.tar.gz: df0259ed2f86592b941a1e966926c21f071e2d1bc059379c68270b5878504a118108336be836fb28a4ba6380f1d44a1da890d45c5df8b7dfabede27b49d90105

data/CHANGELOG.md

@@ -1,8 +1,29 @@
 # Changelog
 
-## [Unreleased](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/HEAD)
+## [v7.1.20](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.1.20) (2022-04-22)
 
-[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.1.17...HEAD)
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.1.19...v7.1.20)
+
+**Implemented enhancements:**
+
+- Manually handle timeouts [\#706](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/706) ([mhenrixon](https://github.com/mhenrixon))
+
+**Merged pull requests:**
+
+- improve README wrt. middleware config [\#704](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/704) ([slhck](https://github.com/slhck))
+
+## [v7.1.19](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.1.19) (2022-04-09)
+
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.1.18...v7.1.19)
+
+**Fixed bugs:**
+
+- concurrent-ruby 1.1.10 spikes volume of jobs [\#701](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/701)
+- Reimplement the entire TimerTask as it was [\#702](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/702) ([mhenrixon](https://github.com/mhenrixon))
+
+## [v7.1.18](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.1.18) (2022-04-05)
+
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.1.17...v7.1.18)
 
 **Implemented enhancements:**
 

data/README.md

@@ -123,9 +123,11 @@ Before v7, the middleware was configured automatically. Since some people report
 
 *NOTE* if you want to use the reaper you also need to configure the server middleware.
 
-[A full example](https://github.com/mhenrixon/sidekiq-unique-jobs/blob/master/myapp/config/initializers/sidekiq.rb#L12)
+The following shows how to modify your `config/initializers/sidekiq.rb` file to use the middleware. [Here is a full example.](https://github.com/mhenrixon/sidekiq-unique-jobs/blob/master/myapp/config/initializers/sidekiq.rb#L12)
 
 ```ruby
+require "sidekiq-unique-jobs"
+
 Sidekiq.configure_server do |config|
   config.redis = { url: ENV["REDIS_URL"], driver: :hiredis }
 

data/lib/sidekiq_unique_jobs/exceptions.rb

@@ -72,14 +72,14 @@ module SidekiqUniqueJobs
   class InvalidUniqueArguments < UniqueJobsError
     def initialize(options)
       given            = options[:given]
-      worker_class     = options[:worker_class]
+      job_class        = options[:job_class]
       lock_args_method = options[:lock_args_method]
-      lock_args_meth   = worker_class.method(lock_args_method)
+      lock_args_meth   = job_class.method(lock_args_method)
       num_args         = lock_args_meth.arity
       source_location  = lock_args_meth.source_location
 
       super(
-        "#{worker_class}##{lock_args_method} takes #{num_args} arguments, received #{given.inspect}" \
+        "#{job_class}##{lock_args_method} takes #{num_args} arguments, received #{given.inspect}" \
         "\n\n" \
         "   #{source_location.join(':')}"
       )

data/lib/sidekiq_unique_jobs/lock_args.rb

@@ -26,9 +26,9 @@ module SidekiqUniqueJobs
 
     # @param [Hash] item a Sidekiq job hash
     def initialize(item)
-      @item         = item
-      @worker_class = item[CLASS]
-      @args         = item[ARGS]
+      @item = item
+      @args = item[ARGS]
+      self.job_class = item[CLASS]
     end
 
     # The unique arguments to use for creating a lock
@@ -83,31 +83,31 @@ module SidekiqUniqueJobs
 
     # Filters unique arguments by method configured in the sidekiq worker
     # @param [Array] args the arguments passed to the sidekiq worker
-    # @return [Array] unfiltered unless {#worker_method_defined?}
+    # @return [Array] unfiltered unless {#job_method_defined?}
     # @return [Array] with the filtered arguments
     def filter_by_symbol(args)
-      return args unless worker_method_defined?(lock_args_method)
+      return args unless job_method_defined?(lock_args_method)
 
-      worker_class.send(lock_args_method, args)
+      job_class.send(lock_args_method, args)
     rescue ArgumentError
       raise SidekiqUniqueJobs::InvalidUniqueArguments,
             given: args,
-            worker_class: worker_class,
+            job_class: job_class,
             lock_args_method: lock_args_method
     end
 
     # The method to use for filtering unique arguments
     def lock_args_method
-      @lock_args_method ||= worker_options.slice(LOCK_ARGS_METHOD, UNIQUE_ARGS_METHOD).values.first
-      @lock_args_method ||= :lock_args if worker_method_defined?(:lock_args)
-      @lock_args_method ||= :unique_args if worker_method_defined?(:unique_args)
+      @lock_args_method ||= job_options.slice(LOCK_ARGS_METHOD, UNIQUE_ARGS_METHOD).values.first
+      @lock_args_method ||= :lock_args if job_method_defined?(:lock_args)
+      @lock_args_method ||= :unique_args if job_method_defined?(:unique_args)
       @lock_args_method ||= default_lock_args_method
     end
 
     # The global worker options defined in Sidekiq directly
     def default_lock_args_method
-      default_worker_options[LOCK_ARGS_METHOD] ||
-        default_worker_options[UNIQUE_ARGS_METHOD]
+      default_job_options[LOCK_ARGS_METHOD] ||
+        default_job_options[UNIQUE_ARGS_METHOD]
     end
 
     #
@@ -116,8 +116,12 @@ module SidekiqUniqueJobs
     #
     # @return [Hash<String, Object>]
     #
-    def default_worker_options
-      @default_worker_options ||= Sidekiq.default_worker_options.stringify_keys
+    def default_job_options
+      @default_job_options ||= if Sidekiq.respond_to?(:default_job_options)
+        Sidekiq.default_job_options.stringify_keys
+      else
+        Sidekiq.default_worker_options.stringify_keys
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/lock_config.rb

@@ -13,9 +13,9 @@ module SidekiqUniqueJobs
     #   @return [Symbol] the type of lock
     attr_reader :type
     #
-    # @!attribute [r] worker
-    #   @return [Symbol] the worker class
-    attr_reader :worker
+    # @!attribute [r] job
+    #   @return [Symbol] the job class
+    attr_reader :job
     #
     # @!attribute [r] limit
     #   @return [Integer] the number of simultaneous locks
@@ -58,7 +58,7 @@ module SidekiqUniqueJobs
 
     def initialize(job_hash = {})
       @type        = job_hash[LOCK]&.to_sym
-      @worker      = SidekiqUniqueJobs.safe_constantize(job_hash[CLASS])
+      @job         = SidekiqUniqueJobs.safe_constantize(job_hash[CLASS])
       @limit       = job_hash.fetch(LOCK_LIMIT, 1)&.to_i
       @timeout     = job_hash.fetch(LOCK_TIMEOUT, 0)&.to_i
       @ttl         = job_hash.fetch(LOCK_TTL) { job_hash.fetch(LOCK_EXPIRATION, nil) }.to_i

data/lib/sidekiq_unique_jobs/lock_digest.rb

@@ -36,10 +36,10 @@ module SidekiqUniqueJobs
 
     # @param [Hash] item a Sidekiq job hash
     def initialize(item)
-      @item         = item
-      @worker_class = item[CLASS]
-      @lock_args    = item[LOCK_ARGS] || item[UNIQUE_ARGS] # TODO: Deprecate UNIQUE_ARGS
-      @lock_prefix  = item[LOCK_PREFIX] || item[UNIQUE_PREFIX] # TODO: Deprecate UNIQUE_PREFIX
+      @item        = item
+      @lock_args   = item[LOCK_ARGS] || item[UNIQUE_ARGS] # TODO: Deprecate UNIQUE_ARGS
+      @lock_prefix = item[LOCK_PREFIX] || item[UNIQUE_PREFIX] # TODO: Deprecate UNIQUE_PREFIX
+      self.job_class = item[CLASS]
     end
 
     # Memoized lock_digest
@@ -67,13 +67,13 @@ module SidekiqUniqueJobs
     # Checks if we should disregard the queue when creating the unique digest
     # @return [true, false]
     def unique_across_queues?
-      item[UNIQUE_ACROSS_QUEUES] || worker_options[UNIQUE_ACROSS_QUEUES]
+      item[UNIQUE_ACROSS_QUEUES] || job_options[UNIQUE_ACROSS_QUEUES]
     end
 
     # Checks if we should disregard the worker when creating the unique digest
     # @return [true, false]
     def unique_across_workers?
-      item[UNIQUE_ACROSS_WORKERS] || worker_options[UNIQUE_ACROSS_WORKERS]
+      item[UNIQUE_ACROSS_WORKERS] || job_options[UNIQUE_ACROSS_WORKERS]
     end
   end
 end

data/lib/sidekiq_unique_jobs/lock_timeout.rb

@@ -30,8 +30,8 @@ module SidekiqUniqueJobs
     # @option item [String] :class the class of the sidekiq worker
     # @option item [Float] :at the unix time the job is scheduled at
     def initialize(item)
-      @item         = item
-      @worker_class = item[CLASS]
+      @item = item
+      self.job_class = item[CLASS]
     end
 
     #
@@ -42,9 +42,9 @@ module SidekiqUniqueJobs
     # @return [Integer, nil]
     #
     def calculate
-      timeout = default_worker_options[LOCK_TIMEOUT]
+      timeout = default_job_options[LOCK_TIMEOUT]
       timeout = default_lock_timeout if default_lock_timeout
-      timeout = worker_options[LOCK_TIMEOUT] if worker_options.key?(LOCK_TIMEOUT)
+      timeout = job_options[LOCK_TIMEOUT] if job_options.key?(LOCK_TIMEOUT)
       timeout
     end
 

data/lib/sidekiq_unique_jobs/lock_ttl.rb

@@ -33,8 +33,8 @@ module SidekiqUniqueJobs
     # @option item [String] :class the class of the sidekiq worker
     # @option item [Float] :at the unix time the job is scheduled at
     def initialize(item)
-      @item         = item
-      @worker_class = item[CLASS]
+      @item = item
+      self.job_class = item[CLASS]
     end
 
     #
@@ -67,9 +67,9 @@ module SidekiqUniqueJobs
     #
     def calculate
       ttl = item[LOCK_TTL]
-      ttl ||= worker_options[LOCK_TTL]
+      ttl ||= job_options[LOCK_TTL]
       ttl ||= item[LOCK_EXPIRATION] # TODO: Deprecate at some point
-      ttl ||= worker_options[LOCK_EXPIRATION] # TODO: Deprecate at some point
+      ttl ||= job_options[LOCK_EXPIRATION] # TODO: Deprecate at some point
       ttl ||= SidekiqUniqueJobs.config.lock_ttl
       ttl && (ttl.to_i + time_until_scheduled)
     end

data/lib/sidekiq_unique_jobs/middleware.rb

@@ -29,10 +29,10 @@ module SidekiqUniqueJobs
     # @yieldparam [<type>] if <description>
     # @yieldreturn [<type>] <describe what yield should return>
     def call(worker_class, item, queue, redis_pool = nil)
-      @worker_class = worker_class
-      @item         = item
-      @queue        = queue
-      @redis_pool   = redis_pool
+      @item       = item
+      @queue      = queue
+      @redis_pool = redis_pool
+      self.job_class = item[CLASS]
       return yield if unique_disabled?
 
       SidekiqUniqueJobs::Job.prepare(item) unless item[LOCK_DIGEST]

data/lib/sidekiq_unique_jobs/on_conflict/reschedule.rb

@@ -14,14 +14,14 @@ module SidekiqUniqueJobs
       # @param [Hash] item sidekiq job hash
       def initialize(item, redis_pool = nil)
         super(item, redis_pool)
-        @worker_class = item[CLASS]
+        self.job_class = item[CLASS]
       end
 
       # Create a new job from the current one.
       #   This will mess up sidekiq stats because a new job is created
       def call
-        if sidekiq_worker_class?
-          if worker_class.set(queue: item["queue"].to_sym).perform_in(5, *item[ARGS])
+        if sidekiq_job_class?
+          if job_class.set(queue: item["queue"].to_sym).perform_in(5, *item[ARGS])
             reflect(:rescheduled, item)
           else
             reflect(:reschedule_failed, item)

data/lib/sidekiq_unique_jobs/options_with_fallback.rb

@@ -6,7 +6,7 @@ module SidekiqUniqueJobs
   # Requires the following methods to be defined in the including class
   #   1. item (required)
   #   2. options (can be nil)
-  #   3. worker_class (required, can be anything)
+  #   3. job_class (required, can be anything)
   # @author Mikael Henriksson <mikael@mhenrixon.com>
   module OptionsWithFallback
     def self.included(base)
@@ -69,8 +69,8 @@ module SidekiqUniqueJobs
     #
     def options
       @options ||= begin
-        opts = default_worker_options.dup
-        opts.merge!(worker_options) if sidekiq_worker_class?
+        opts = default_job_options.dup
+        opts.merge!(job_options) if sidekiq_job_class?
         (opts || {}).stringify_keys
       end
     end

data/lib/sidekiq_unique_jobs/orphans/manager.rb

@@ -110,13 +110,7 @@ module SidekiqUniqueJobs
       # @return [Hash]
       #
       def timer_task_options
-        timer_task_options = { run_now: true, execution_interval: reaper_interval }
-
-        if VersionCheck.satisfied?(::Concurrent::VERSION, "< 1.1.10")
-          timer_task_options[:timeout_interval] = reaper_timeout
-        end
-
-        timer_task_options
+        { run_now: true, execution_interval: reaper_interval }
       end
 
       #
@@ -133,13 +127,6 @@ module SidekiqUniqueJobs
         SidekiqUniqueJobs.config.reaper_interval
       end
 
-      #
-      # @see SidekiqUniqueJobs::Config#reaper_timeout
-      #
-      def reaper_timeout
-        SidekiqUniqueJobs.config.reaper_timeout
-      end
-
       #
       # A context to use for all log entries
       #

data/lib/sidekiq_unique_jobs/orphans/ruby_reaper.rb

@@ -11,6 +11,8 @@ module SidekiqUniqueJobs
     #
     # rubocop:disable Metrics/ClassLength
     class RubyReaper < Reaper
+      include SidekiqUniqueJobs::Timing
+
       #
       # @return [String] the suffix for :RUN locks
       RUN_SUFFIX = ":RUN"
@@ -30,6 +32,16 @@ module SidekiqUniqueJobs
       #   @return [Redis::SortedSet] the Sidekiq RetrySet
       attr_reader :retried
 
+      #
+      # @!attribute [r] start_time
+      #   @return [Integer] The timestamp this execution started represented as integer
+      attr_reader :start_time
+
+      #
+      # @!attribute [r] timeout_ms
+      #   @return [Integer] The allowed ms before timeout
+      attr_reader :timeout_ms
+
       #
       # Initialize a new instance of DeleteOrphans
       #
@@ -37,9 +49,11 @@ module SidekiqUniqueJobs
       #
       def initialize(conn)
         super(conn)
-        @digests   = SidekiqUniqueJobs::Digests.new
-        @scheduled = Redis::SortedSet.new(SCHEDULE)
-        @retried   = Redis::SortedSet.new(RETRY)
+        @digests    = SidekiqUniqueJobs::Digests.new
+        @scheduled  = Redis::SortedSet.new(SCHEDULE)
+        @retried    = Redis::SortedSet.new(RETRY)
+        @start_time = time_source.call
+        @timeout_ms = SidekiqUniqueJobs.config.reaper_timeout * 1000
       end
 
       #
@@ -60,7 +74,7 @@ module SidekiqUniqueJobs
       #
       # @return [Array<String>] an array of orphaned digests
       #
-      def orphans # rubocop:disable Metrics/MethodLength
+      def orphans # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         page = 0
         per = reaper_count * 2
         orphans = []
@@ -68,12 +82,14 @@ module SidekiqUniqueJobs
 
         while results.size.positive?
           results.each do |digest|
+            break if timeout?
             next if belongs_to_job?(digest)
 
             orphans << digest
             break if orphans.size >= reaper_count
           end
 
+          break if timeout?
           break if orphans.size >= reaper_count
 
           page += 1
@@ -83,6 +99,14 @@ module SidekiqUniqueJobs
         orphans
       end
 
+      def timeout?
+        elapsed_ms >= timeout_ms
+      end
+
+      def elapsed_ms
+        time_source.call - start_time
+      end
+
       #
       # Checks if the digest has a matching job.
       #   1. It checks the scheduled set

data/lib/sidekiq_unique_jobs/sidekiq_worker_methods.rb

@@ -5,50 +5,55 @@ module SidekiqUniqueJobs
   #
   # @author Mikael Henriksson <mikael@mhenrixon.com>
   module SidekiqWorkerMethods
+    #
+    # @!attribute [r] job_class
+    #   @return [Sidekiq::Worker] The Sidekiq::Worker implementation
+    attr_reader :job_class
+
     # Avoids duplicating worker_class.respond_to? in multiple places
     # @return [true, false]
-    def worker_method_defined?(method_sym)
-      worker_class.respond_to?(method_sym)
+    def job_method_defined?(method_sym)
+      job_class.respond_to?(method_sym)
     end
 
     # Wraps #get_sidekiq_options to always work with a hash
     # @return [Hash] of the worker class sidekiq options
-    def worker_options
-      return {} unless sidekiq_worker_class?
+    def job_options
+      return {} unless sidekiq_job_class?
 
-      worker_class.get_sidekiq_options.deep_stringify_keys
+      job_class.get_sidekiq_options.deep_stringify_keys
     end
 
     # Tests that the
-    # @return [true] if worker_class responds to get_sidekiq_options
-    # @return [false] if worker_class does not respond to get_sidekiq_options
-    def sidekiq_worker_class?
-      worker_method_defined?(:get_sidekiq_options)
+    # @return [true] if job_class responds to get_sidekiq_options
+    # @return [false] if job_class does not respond to get_sidekiq_options
+    def sidekiq_job_class?
+      job_method_defined?(:get_sidekiq_options)
     end
 
-    # The Sidekiq::Worker implementation
-    # @return [Sidekiq::Worker]
-    def worker_class
-      @_worker_class ||= worker_class_constantize # rubocop:disable Naming/MemoizedInstanceVariableName
+    def job_class=(obj)
+      # this is what was originally passed in, it can be an instance or a class depending on sidekiq version
+      @original_job_class = obj
+      @job_class = job_class_constantize(obj)
     end
 
     # The hook to call after a successful unlock
     # @return [Proc]
     def after_unlock_hook # rubocop:disable Metrics/MethodLength
       lambda do
-        if @worker_class.respond_to?(:after_unlock)
+        if @original_job_class.respond_to?(:after_unlock)
           # instance method in sidekiq v6
-          if @worker_class.method(:after_unlock).arity.positive? # arity check to maintain backwards compatibility
-            @worker_class.after_unlock(item)
+          if @original_job_class.method(:after_unlock).arity.positive? # arity check to maintain backwards compatibility
+            @original_job_class.after_unlock(item)
           else
-            @worker_class.after_unlock
+            @original_job_class.after_unlock
           end
-        elsif worker_class.respond_to?(:after_unlock)
+        elsif job_class.respond_to?(:after_unlock)
           # class method regardless of sidekiq version
-          if worker_class.method(:after_unlock).arity.positive? # arity check to maintain backwards compatibility
-            worker_class.after_unlock(item)
+          if job_class.method(:after_unlock).arity.positive? # arity check to maintain backwards compatibility
+            job_class.after_unlock(item)
           else
-            worker_class.after_unlock
+            job_class.after_unlock
           end
         end
       end
@@ -58,7 +63,7 @@ module SidekiqUniqueJobs
     # failing back to the original argument when the constant can't be found
     #
     # @return [Sidekiq::Worker]
-    def worker_class_constantize(klazz = @worker_class)
+    def job_class_constantize(klazz = @job_class)
       SidekiqUniqueJobs.safe_constantize(klazz)
     end
 
@@ -68,8 +73,12 @@ module SidekiqUniqueJobs
     #
     # @return [Hash<Symbol, Object>]
     #
-    def default_worker_options
-      Sidekiq.default_worker_options
+    def default_job_options
+      if Sidekiq.respond_to?(:default_job_options)
+        Sidekiq.default_job_options
+      else
+        Sidekiq.default_worker_options
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/timer_task.rb

@@ -1,84 +1,299 @@
 # frozen_string_literal: true
 
-require "concurrent/version"
-require_relative "version_check"
+require "concurrent/collection/copy_on_notify_observer_set"
+require "concurrent/concern/dereferenceable"
+require "concurrent/concern/observable"
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/executor/executor_service"
+require "concurrent/executor/ruby_executor_service"
+require "concurrent/executor/safe_task_executor"
+require "concurrent/scheduled_task"
 
 module SidekiqUniqueJobs
-  # @see [Concurrent::TimerTask] https://www.rubydoc.info/gems/concurrent-ruby/Concurrent/TimerTask
+  # A very common concurrency pattern is to run a thread that performs a task at
+  # regular intervals. The thread that performs the task sleeps for the given
+  # interval then wakes up and performs the task. Lather, rinse, repeat... This
+  # pattern causes two problems. First, it is difficult to test the business
+  # logic of the task because the task itself is tightly coupled with the
+  # concurrency logic. Second, an exception raised while performing the task can
+  # cause the entire thread to abend. In a long-running application where the
+  # task thread is intended to run for days/weeks/years a crashed task thread
+  # can pose a significant problem. `TimerTask` alleviates both problems.
   #
-  class TimerTask < ::Concurrent::TimerTask
-    if VersionCheck.satisfied?(::Concurrent::VERSION, "< 1.1.10")
+  # When a `TimerTask` is launched it starts a thread for monitoring the
+  # execution interval. The `TimerTask` thread does not perform the task,
+  # however. Instead, the TimerTask launches the task on a separate thread.
+  # Should the task experience an unrecoverable crash only the task thread will
+  # crash. This makes the `TimerTask` very fault tolerant. Additionally, the
+  # `TimerTask` thread can respond to the success or failure of the task,
+  # performing logging or ancillary operations.
+  #
+  # One other advantage of `TimerTask` is that it forces the business logic to
+  # be completely decoupled from the concurrency logic. The business logic can
+  # be tested separately then passed to the `TimerTask` for scheduling and
+  # running.
+  #
+  # In some cases it may be necessary for a `TimerTask` to affect its own
+  # execution cycle. To facilitate this, a reference to the TimerTask instance
+  # is passed as an argument to the provided block every time the task is
+  # executed.
+  #
+  # The `TimerTask` class includes the `Dereferenceable` mixin module so the
+  # result of the last execution is always available via the `#value` method.
+  # Dereferencing options can be passed to the `TimerTask` during construction or
+  # at any later time using the `#set_deref_options` method.
+  #
+  # `TimerTask` supports notification through the Ruby standard library
+  # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
+  # Observable} module. On execution the `TimerTask` will notify the observers
+  # with three arguments: time of execution, the result of the block (or nil on
+  # failure), and any raised exceptions (or nil on success).
+  #
+  # @!macro copy_options
+  #
+  # @example Basic usage
+  #   task = Concurrent::TimerTask.new{ puts 'Boom!' }
+  #   task.execute
+  #
+  #   task.execution_interval #=> 60 (default)
+  #
+  #   # wait 60 seconds...
+  #   #=> 'Boom!'
+  #
+  #   task.shutdown #=> true
+  #
+  # @example Configuring `:execution_interval`
+  #   task = Concurrent::TimerTask.new(execution_interval: 5) do
+  #          puts 'Boom!'
+  #        end
+  #
+  #   task.execution_interval #=> 5
+  #
+  # @example Immediate execution with `:run_now`
+  #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
+  #   task.execute
+  #
+  #   #=> 'Boom!'
+  #
+  # @example Last `#value` and `Dereferenceable` mixin
+  #   task = Concurrent::TimerTask.new(
+  #     dup_on_deref: true,
+  #     execution_interval: 5
+  #   ){ Time.now }
+  #
+  #   task.execute
+  #   Time.now   #=> 2013-11-07 18:06:50 -0500
+  #   sleep(10)
+  #   task.value #=> 2013-11-07 18:06:55 -0500
+  #
+  # @example Controlling execution from within the block
+  #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
+  #     task.execution_interval.times{ print 'Boom! ' }
+  #     print "\n"
+  #     task.execution_interval += 1
+  #     if task.execution_interval > 5
+  #       puts 'Stopping...'
+  #       task.shutdown
+  #     end
+  #   end
+  #
+  #   timer_task.execute # blocking call - this task will stop itself
+  #   #=> Boom!
+  #   #=> Boom! Boom!
+  #   #=> Boom! Boom! Boom!
+  #   #=> Boom! Boom! Boom! Boom!
+  #   #=> Boom! Boom! Boom! Boom! Boom!
+  #   #=> Stopping...
+  #
+  # @example Observation
+  #   class TaskObserver
+  #     def update(time, result, ex)
+  #       if result
+  #         print "(#{time}) Execution successfully returned #{result}\n"
+  #       else
+  #         print "(#{time}) Execution failed with error #{ex}\n"
+  #       end
+  #     end
+  #   end
+  #
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ 42 }
+  #   task.add_observer(TaskObserver.new)
+  #   task.execute
+  #   sleep 4
+  #
+  #   #=> (2013-10-13 19:08:58 -0400) Execution successfully returned 42
+  #   #=> (2013-10-13 19:08:59 -0400) Execution successfully returned 42
+  #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
+  #   task.shutdown
+  #
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ sleep }
+  #   task.add_observer(TaskObserver.new)
+  #   task.execute
+  #
+  #   #=> (2013-10-13 19:07:25 -0400) Execution timed out
+  #   #=> (2013-10-13 19:07:27 -0400) Execution timed out
+  #   #=> (2013-10-13 19:07:29 -0400) Execution timed out
+  #   task.shutdown
+  #
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ raise StandardError }
+  #   task.add_observer(TaskObserver.new)
+  #   task.execute
+  #
+  #   #=> (2013-10-13 19:09:37 -0400) Execution failed with error StandardError
+  #   #=> (2013-10-13 19:09:38 -0400) Execution failed with error StandardError
+  #   #=> (2013-10-13 19:09:39 -0400) Execution failed with error StandardError
+  #   task.shutdown
+  #
+  # @see http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
+  # @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
+  class TimerTask < Concurrent::RubyExecutorService
+    include Concurrent::Concern::Dereferenceable
+    include Concurrent::Concern::Observable
 
-      private
+    # Default `:execution_interval` in seconds.
+    EXECUTION_INTERVAL = 60
 
-      def ns_initialize(opts, &task)
-        set_deref_options(opts)
+    # Default `:timeout_interval` in seconds.
+    TIMEOUT_INTERVAL = 30
 
-        self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-        self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
-        @run_now  = opts[:now] || opts[:run_now]
-        @executor = Concurrent::RubySingleThreadExecutor.new
-        @running  = Concurrent::AtomicBoolean.new(false)
-        @task     = task
-        @value    = nil
+    # Create a new TimerTask with the given task and configuration.
+    #
+    # @!macro timer_task_initialize
+    #   @param [Hash] opts the options defining task execution.
+    #   @option opts [Integer] :execution_interval number of seconds between
+    #     task executions (default: EXECUTION_INTERVAL)
+    #   @option opts [Boolean] :run_now Whether to run the task immediately
+    #     upon instantiation or to wait until the first #  execution_interval
+    #     has passed (default: false)
+    #
+    #   @!macro deref_options
+    #
+    #   @raise ArgumentError when no block is given.
+    #
+    #   @yield to the block after :execution_interval seconds have passed since
+    #     the last yield
+    #   @yieldparam task a reference to the `TimerTask` instance so that the
+    #     block can control its own lifecycle. Necessary since `self` will
+    #     refer to the execution context of the block rather than the running
+    #     `TimerTask`.
+    #
+    #   @return [TimerTask] the new `TimerTask`
+    def initialize(opts = {}, &task)
+      raise ArgumentError, "no block given" unless task
 
-        self.observers = Concurrent::Collection::CopyOnNotifyObserverSet.new
-      end
+      super
+      set_deref_options opts
+    end
 
-      def schedule_next_task(interval = execution_interval)
-        exec_task = ->(completion) { execute_task(completion) }
-        Concurrent::ScheduledTask.execute(interval, args: [Concurrent::Event.new], &exec_task)
-        nil
-      end
+    # Is the executor running?
+    #
+    # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+    def running?
+      @running.true?
+    end
 
-      # @!visibility private
-      def execute_task(completion) # rubocop:disable Metrics/MethodLength
-        return nil unless @running.true?
-
-        timeout_task = -> { timeout_task(completion) }
-
-        Concurrent::ScheduledTask.execute(
-          timeout_interval,
-          args: [completion],
-          &timeout_task
-        )
-        @thread_completed = Concurrent::Event.new
-
-        @value = @reason  = nil
-        @executor.post do
-          @value = @task.call(self)
-        rescue Exception => ex # rubocop:disable Lint/RescueException
-          @reason = ex
-        ensure
-          @thread_completed.set
+    # Execute a previously created `TimerTask`.
+    #
+    # @return [TimerTask] a reference to `self`
+    #
+    # @example Instance and execute in separate steps
+    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> false
+    #   task.execute
+    #   task.running? #=> true
+    #
+    # @example Instance and execute in one line
+    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }.execute
+    #   task.running? #=> true
+    def execute
+      synchronize do
+        if @running.false?
+          @running.make_true
+          schedule_next_task(@run_now ? 0 : @execution_interval)
         end
+      end
+      self
+    end
 
-        @thread_completed.wait
+    # Create and execute a new `TimerTask`.
+    #
+    # @!macro timer_task_initialize
+    #
+    # @example
+    #   task = Concurrent::TimerTask.execute(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> true
+    def self.execute(opts = {}, &task)
+      TimerTask.new(opts, &task).execute
+    end
 
-        if completion.try?
-          schedule_next_task
-          time = Time.now
-          observers.notify_observers do
-            [time, value, @reason]
-          end
-        end
-        nil
+    # @!attribute [rw] execution_interval
+    # @return [Fixnum] Number of seconds after the task completes before the
+    #   task is performed again.
+    def execution_interval
+      synchronize { @execution_interval }
+    end
+
+    # @!attribute [rw] execution_interval
+    # @return [Fixnum] Number of seconds after the task completes before the
+    #   task is performed again.
+    def execution_interval=(value)
+      raise ArgumentError, "must be greater than zero" if (value = value.to_f) <= 0.0
+
+      synchronize { @execution_interval = value }
+    end
+
+    private :post, :<<
+
+    private
+
+    def ns_initialize(opts, &task)
+      set_deref_options(opts)
+
+      self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      if opts[:timeout] || opts[:timeout_interval]
+        warn "TimeTask timeouts are now ignored as these were not able to be implemented correctly"
       end
+      @run_now = opts[:now] || opts[:run_now]
+      @executor = Concurrent::SafeTaskExecutor.new(task)
+      @running = Concurrent::AtomicBoolean.new(false)
+      @value = nil
+
+      self.observers = Concurrent::Collection::CopyOnNotifyObserverSet.new
+    end
+
+    # @!visibility private
+    def ns_shutdown_execution
+      @running.make_false
+      super
+    end
 
-      # @!visibility private
-      def timeout_task(completion)
-        return unless @running.true?
-        return unless completion.try?
+    # @!visibility private
+    def ns_kill_execution
+      @running.make_false
+      super
+    end
 
-        @executor.kill
-        @executor.wait_for_termination
-        @executor = Concurrent::RubySingleThreadExecutor.new
+    # @!visibility private
+    def schedule_next_task(interval = execution_interval)
+      exec_task = ->(completion) { execute_task(completion) }
+      Concurrent::ScheduledTask.execute(interval, args: [Concurrent::Event.new], &exec_task)
+      nil
+    end
 
-        @thread_completed.set
+    # @!visibility private
+    def execute_task(completion)
+      return nil unless @running.true?
 
+      _success, value, reason = @executor.execute(self)
+      if completion.try?
+        self.value = value
         schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
+        time = Time.now
+        observers.notify_observers do
+          [time, self.value, reason]
+        end
       end
+      nil
     end
   end
 end

data/lib/sidekiq_unique_jobs/version.rb

@@ -3,5 +3,5 @@
 module SidekiqUniqueJobs
   #
   # @return [String] the current SidekiqUniqueJobs version
-  VERSION = "7.1.18"
+  VERSION = "7.1.21"
 end

data/lib/tasks/changelog.rake

@@ -17,7 +17,7 @@ COMMIT_CHANGELOG_CMD = "git commit -a -m 'Update changelog'"
 desc "Generate a Changelog"
 task :changelog do
   sh("git checkout main")
-  sh(*CHANGELOG_CMD.push(ENV["CHANGELOG_GITHUB_TOKEN"]))
+  sh(*CHANGELOG_CMD.push(ENV.fetch("CHANGELOG_GITHUB_TOKEN", nil)))
   sh(ADD_CHANGELOG_CMD)
   sh(COMMIT_CHANGELOG_CMD)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-unique-jobs
 version: !ruby/object:Gem::Version
-  version: 7.1.18
+  version: 7.1.21
 platform: ruby
 authors:
 - Mikael Henriksson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: brpoplpush-redis_script