sidekiq-unique-jobs 6.0.24 → 7.0.4

data/lib/sidekiq_unique_jobs/on_conflict/null_strategy.rb

@@ -4,7 +4,7 @@ module SidekiqUniqueJobs
   module OnConflict
     # Default conflict strategy class that does nothing
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class NullStrategy < OnConflict::Strategy
       # Do nothing on conflict
       # @return [nil]

data/lib/sidekiq_unique_jobs/on_conflict/raise.rb

@@ -4,7 +4,7 @@ module SidekiqUniqueJobs
   module OnConflict
     # Strategy to raise an error on conflict
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Raise < OnConflict::Strategy
       # Raise an error on conflict.
       #   This will cause Sidekiq to retry the job

data/lib/sidekiq_unique_jobs/on_conflict/reject.rb

@@ -4,16 +4,13 @@ module SidekiqUniqueJobs
   module OnConflict
     # Strategy to send jobs to dead queue
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Reject < OnConflict::Strategy
+      include SidekiqUniqueJobs::Timing
+
       # Send jobs to dead queue
       def call
-        log_debug { "Rejecting job with jid: #{item[JID_KEY]}" }
-        send_to_deadset
-      end
-
-      def send_to_deadset
-        log_info { "Adding dead #{item[CLASS_KEY]} job #{item[JID_KEY]}" }
+        log_info { "Adding dead #{item[CLASS]} job #{item[JID]}" }
 
         if deadset_kill?
           deadset_kill
@@ -22,10 +19,25 @@ module SidekiqUniqueJobs
         end
       end
 
+      #
+      # Sidekiq version compatibility check
+      # @api private
+      #
+      #
+      # @return [true, false] depending on if Sidekiq::Deadset responds to kill
+      #
       def deadset_kill?
         deadset.respond_to?(:kill)
       end
 
+      #
+      # Use Sidekiqs built in Sidekiq::DeadSet#kill
+      #   to get rid of the job
+      # @api private
+      #
+      #
+      # @return [void]
+      #
       def deadset_kill
         if kill_with_options?
           kill_job_with_options
@@ -34,38 +46,72 @@ module SidekiqUniqueJobs
         end
       end
 
+      #
+      # Sidekiq version compatibility check
+      # @api private
+      #
+      #
+      # @return [true] when Sidekiq::Deadset#kill takes more than 1 argument
+      # @return [false] when Sidekiq::Deadset#kill does not take multiple arguments
+      #
       def kill_with_options?
         Sidekiq::DeadSet.instance_method(:kill).arity > 1
       end
 
+      #
+      # Executes the kill instructions without arguments
+      # @api private
+      #
+      # @return [void]
+      #
       def kill_job_without_options
         deadset.kill(payload)
       end
 
+      #
+      # Executes the kill instructions with arguments
+      # @api private
+      #
+      # @return [void]
+      #
       def kill_job_with_options
         deadset.kill(payload, notify_failure: false)
       end
 
+      #
+      # An instance of Sidekiq::Deadset
+      # @api private
+      #
+      # @return [Sidekiq::Deadset]>
+      #
       def deadset
         @deadset ||= Sidekiq::DeadSet.new
       end
 
+      #
+      # Used for compatibility with older Sidekiq versions
+      #
+      #
+      # @return [void]
+      #
       def push_to_deadset
-        Sidekiq.redis do |conn|
+        redis do |conn|
           conn.multi do
-            conn.zadd("dead", current_time, payload)
-            conn.zremrangebyscore("dead", "-inf", current_time - Sidekiq::DeadSet.timeout)
+            conn.zadd("dead", now_f, payload)
+            conn.zremrangebyscore("dead", "-inf", now_f - Sidekiq::DeadSet.timeout)
             conn.zremrangebyrank("dead", 0, -Sidekiq::DeadSet.max_jobs)
           end
         end
       end
 
-      def current_time
-        @current_time ||= Time.now.to_f
-      end
-
+      #
+      # The Sidekiq job hash as JSON
+      #
+      #
+      # @return [String] a JSON formatted string
+      #
       def payload
-        @payload ||= Sidekiq.dump_json(item)
+        @payload ||= dump_json(item)
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/replace.rb

@@ -4,38 +4,78 @@ module SidekiqUniqueJobs
   module OnConflict
     # Strategy to replace the job on conflict
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Replace < OnConflict::Strategy
-      attr_reader :queue, :unique_digest
+      #
+      # @!attribute [r] queue
+      #   @return [String] rthe sidekiq queue this job belongs to
+      attr_reader :queue
+      #
+      # @!attribute [r] lock_digest
+      #   @return [String] the unique digest to use for locking
+      attr_reader :lock_digest
 
+      #
+      # Initialize a new Replace strategy
+      #
       # @param [Hash] item sidekiq job hash
-      def initialize(item)
-        super
-        @queue         = item[QUEUE_KEY]
-        @unique_digest = item[UNIQUE_DIGEST_KEY]
+      #
+      def initialize(item, redis_pool = nil)
+        super(item, redis_pool)
+        @queue       = item[QUEUE]
+        @lock_digest = item[LOCK_DIGEST]
       end
 
+      #
       # Replace the old job in the queue
+      #
+      #
+      # @return [void] <description>
+      #
       # @yield to retry the lock after deleting the old one
+      #
       def call(&block)
-        return unless delete_job_by_digest
+        return unless (deleted_job = delete_job_by_digest)
+
+        log_info("Deleted job: #{deleted_job}")
+        if (del_count = delete_lock)
+          log_info("Deleted `#{del_count}` keys for #{lock_digest}")
+        end
 
-        delete_lock
         block&.call
       end
 
+      #
       # Delete the job from either schedule, retry or the queue
+      #
+      #
+      # @return [String] the deleted job hash
+      # @return [nil] when deleting nothing
+      #
       def delete_job_by_digest
-        Scripts.call(
-          :delete_job_by_digest,
-          nil,
-          keys: ["#{QUEUE_KEY}:#{queue}", SCHEDULE_SET, RETRY_SET], argv: [unique_digest],
-        )
+        call_script(:delete_job_by_digest,
+                    keys: ["#{QUEUE}:#{queue}", SCHEDULE, RETRY],
+                    argv: [lock_digest])
       end
 
+      #
       # Delete the keys belonging to the job
+      #
+      #
+      # @return [Integer] the number of keys deleted
+      #
       def delete_lock
-        SidekiqUniqueJobs::Digests.delete_by_digest(unique_digest)
+        digests.delete_by_digest(lock_digest)
+      end
+
+      #
+      # Access to the {Digests}
+      #
+      #
+      # @return [Digests] and instance with digests
+      #
+      def digests
+        @digests ||= SidekiqUniqueJobs::Digests.new
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/reschedule.rb

@@ -4,20 +4,27 @@ module SidekiqUniqueJobs
   module OnConflict
     # Strategy to reschedule job on conflict
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Reschedule < OnConflict::Strategy
       include SidekiqUniqueJobs::SidekiqWorkerMethods
+      include SidekiqUniqueJobs::Logging
+      include SidekiqUniqueJobs::JSON
 
       # @param [Hash] item sidekiq job hash
-      def initialize(item)
-        super
-        @worker_class = item[CLASS_KEY]
+      def initialize(item, redis_pool = nil)
+        super(item, redis_pool)
+        @worker_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
-        worker_class&.perform_in(5, *item[ARGS_KEY]) if sidekiq_worker_class?
+        if sidekiq_worker_class?
+          log_info("Rescheduling #{item[LOCK_DIGEST]}")
+          worker_class.perform_in(5, *item[ARGS])
+        else
+          log_warn("Skip rescheduling of #{item[LOCK_DIGEST]} because #{worker_class} is not a Sidekiq::Worker")
+        end
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/strategy.rb

@@ -5,17 +5,29 @@ module SidekiqUniqueJobs
     # Abstract conflict strategy class
     #
     # @abstract
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Strategy
+      include SidekiqUniqueJobs::JSON
       include SidekiqUniqueJobs::Logging
+      include SidekiqUniqueJobs::Script::Caller
+      include SidekiqUniqueJobs::Timing
 
-      # The sidekiq job hash
-      # @return [Hash] the Sidekiq job hash
+      # @!attribute [r] item
+      #   @return [Hash] sidekiq job hash
       attr_reader :item
+      # @!attribute [r] redis_pool
+      #   @return [Sidekiq::RedisConnection, ConnectionPool, NilClass] the redis connection
+      attr_reader :redis_pool
 
-      # @param [Hash] item the Sidekiq job hash
-      def initialize(item)
-        @item = item
+      #
+      # Initialize a new Strategy
+      #
+      # @param [Hash] item sidekiq job hash
+      # @param [ConnectionPool] redis_pool the connection pool instance
+      #
+      def initialize(item, redis_pool = nil)
+        @item       = item
+        @redis_pool = redis_pool
       end
 
       # Use strategy on conflict
@@ -24,6 +36,13 @@ module SidekiqUniqueJobs
         raise NotImplementedError, "needs to be implemented in child class"
       end
 
+      #
+      # Check if the strategy is kind of {Replace}
+      #
+      #
+      # @return [true] when the strategy is a {Replace}
+      # @return [false] when the strategy is not a {Replace}
+      #
       def replace?
         is_a?(Replace)
       end

data/lib/sidekiq_unique_jobs/options_with_fallback.rb

@@ -7,26 +7,21 @@ module SidekiqUniqueJobs
   #   1. item (required)
   #   2. options (can be nil)
   #   3. worker_class (required, can be anything)
-  # @author Mikael Henriksson <mikael@zoolutions.se>
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
   module OptionsWithFallback
-    LOCKS = {
-      until_and_while_executing: SidekiqUniqueJobs::Lock::UntilAndWhileExecuting,
-      until_executed: SidekiqUniqueJobs::Lock::UntilExecuted,
-      until_executing: SidekiqUniqueJobs::Lock::UntilExecuting,
-      until_expired: SidekiqUniqueJobs::Lock::UntilExpired,
-      until_timeout: SidekiqUniqueJobs::Lock::UntilExpired,
-      while_executing: SidekiqUniqueJobs::Lock::WhileExecuting,
-      while_executing_reject: SidekiqUniqueJobs::Lock::WhileExecutingReject,
-    }.freeze
-
     def self.included(base)
       base.send(:include, SidekiqUniqueJobs::SidekiqWorkerMethods)
     end
 
+    # A convenience method for using the configured locks
+    def locks
+      SidekiqUniqueJobs.locks
+    end
+
     # Check if unique has been enabled
     # @return [true, false] indicate if the gem has been enabled
     def unique_enabled?
-      SidekiqUniqueJobs.config.enabled && lock_type
+      SidekiqUniqueJobs.enabled? && lock_type
     end
 
     # Check if unique has been disabled
@@ -34,36 +29,55 @@ module SidekiqUniqueJobs
       !unique_enabled?
     end
 
-    # Check if we should log duplicate payloads
-    def log_duplicate_payload?
-      options[LOG_DUPLICATE_KEY] || item[LOG_DUPLICATE_KEY]
+    # Should duplicate payloads be logged?
+    #
+    #
+    # @return [true, false, nil]
+    #
+    def log_duplicate?
+      options[LOG_DUPLICATE] || item[LOG_DUPLICATE]
     end
 
-    # Check if we should log duplicate payloads
-    # @return [SidekiqUniqueJobs::Lock::BaseLock] an instance of a child class
-    def lock
-      @lock ||= lock_class.new(item, after_unlock_hook, @redis_pool)
+    #
+    # A new lock for this Sidekiq Job
+    #
+    #
+    # @return [Lock::BaseLock] an instance of a lock implementation
+    #
+    def lock_instance
+      @lock_instance ||= lock_class.new(item, after_unlock_hook, @redis_pool)
     end
 
-    # Check if we should log duplicate payloads
-    # @return [SidekiqUniqueJobs::Lock::BaseLock] an instance of a child class
+    #
+    # Returns the corresponding class for the lock_type
+    #
+    #
+    # @return [Class]
+    #
     def lock_class
       @lock_class ||= begin
-        LOCKS.fetch(lock_type.to_sym) do
+        locks.fetch(lock_type.to_sym) do
           raise UnknownLock, "No implementation for `lock: :#{lock_type}`"
         end
       end
     end
 
+    #
+    # The type of lock for this worker
+    #
+    #
     # @return [Symbol]
+    #
     def lock_type
-      @lock_type ||= item[LOCK_KEY] || options[LOCK_KEY] || unique_type
-    end
-
-    def unique_type
-      options[UNIQUE_KEY] || item[UNIQUE_KEY]
+      @lock_type ||= options[LOCK] || item[LOCK]
     end
 
+    #
+    # The default options with any matching keys overridden from worker options
+    #
+    #
+    # @return [Hash<String, Object>]
+    #
     def options
       @options ||= begin
         opts = default_worker_options.dup

data/lib/sidekiq_unique_jobs/orphans/lua_reaper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Orphans
+    #
+    # Class DeleteOrphans provides deletion of orphaned digests
+    #
+    # @note this is a much slower version of the lua script but does not crash redis
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    class LuaReaper < Reaper
+      #
+      # Delete orphaned digests
+      #
+      #
+      # @return [Integer] the number of reaped locks
+      #
+      def call
+        call_script(
+          :reap_orphans,
+          conn,
+          keys: [DIGESTS, SCHEDULE, RETRY, PROCESSES],
+          argv: [reaper_count, (Time.now - reaper_timeout).to_f],
+        )
+      end
+    end
+  end
+end