sidekiq-unique-jobs 6.0.25 → 7.0.0.beta2

data/lib/sidekiq_unique_jobs/normalizer.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require "json"
-
 module SidekiqUniqueJobs
   # Normalizes hashes by dumping them to json and loading them from json
   #
   # @author Mikael Henriksson <mikael@zoolutions.se>
   module Normalizer
+    extend SidekiqUniqueJobs::JSON
+
     # Changes hash to a json compatible hash
     # @param [Hash] args
     # @return [Hash] a json compatible hash
     def self.jsonify(args)
-      Sidekiq.load_json(Sidekiq.dump_json(args))
+      load_json(dump_json(args))
     end
   end
 end

data/lib/sidekiq_unique_jobs/on_conflict.rb

@@ -15,17 +15,30 @@ module SidekiqUniqueJobs
   # @author Mikael Henriksson <mikael@zoolutions.se>
   #
   module OnConflict
-    STRATEGIES = {
-      log: OnConflict::Log,
-      raise: OnConflict::Raise,
-      reject: OnConflict::Reject,
-      replace: OnConflict::Replace,
-      reschedule: OnConflict::Reschedule,
-    }.freeze
+    # A convenience method for using the configured strategies
+    def self.strategies
+      SidekiqUniqueJobs.strategies
+    end
 
-    # returns OnConflict::NullStrategy when no other could be found
+    #
+    # Find a strategy to use for conflicting locks
+    #
+    # @param [Symbol] strategy the key for the strategy
+    #
+    # @return [OnConflict::Strategy] when found
+    # @return [OnConflict::NullStrategy] when no other could be found
+    #
     def self.find_strategy(strategy)
-      STRATEGIES.fetch(strategy.to_s.to_sym) { OnConflict::NullStrategy }
+      return OnConflict::NullStrategy unless strategy
+
+      strategies.fetch(strategy.to_sym) do
+        SidekiqUniqueJobs.logger.warn(
+          "No matching implementation for strategy: #{strategy}, returning OnConflict::NullStrategy." \
+          " Available strategies are (#{strategies.inspect})",
+        )
+
+        OnConflict::NullStrategy
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/on_conflict/log.rb

@@ -8,12 +8,16 @@ module SidekiqUniqueJobs
     class Log < OnConflict::Strategy
       include SidekiqUniqueJobs::Logging
 
+      #
       # Logs an informational message about that the job was not unique
+      #
+      #
+      # @return [void]
+      #
       def call
-        log_info(
-          "skipping job with id (#{item[JID_KEY]}) " \
-          "because unique_digest: (#{item[UNIQUE_DIGEST_KEY]}) already exists",
-        )
+        log_info(<<~MESSAGE.chomp)
+          Skipping job with id (#{item[JID]}) because unique_digest: (#{item[UNIQUE_DIGEST]}) already exists
+        MESSAGE
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/reject.rb

@@ -6,14 +6,11 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@zoolutions.se>
     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,36 +46,70 @@ 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)
       end

data/lib/sidekiq_unique_jobs/on_conflict/replace.rb

@@ -6,36 +6,65 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@zoolutions.se>
     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] unique_digest
+      #   @return [String] the unique digest to use for locking
+      attr_reader :unique_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]
+        @unique_digest = item[UNIQUE_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)
 
-        delete_lock
+        log_info("Deleting job: #{deleted_job}")
+        if (del_count = delete_lock)
+          log_info("Deleted `#{del_count}` keys for #{unique_digest}")
+        end
         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: [unique_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)
+        call_script(:delete_by_digest, keys: [unique_digest, DIGESTS])
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/reschedule.rb

@@ -9,15 +9,15 @@ module SidekiqUniqueJobs
       include SidekiqUniqueJobs::SidekiqWorkerMethods
 
       # @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?
+        worker_class&.perform_in(5, *item[ARGS]) if sidekiq_worker_class?
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/strategy.rb

@@ -7,15 +7,27 @@ module SidekiqUniqueJobs
     # @abstract
     # @author Mikael Henriksson <mikael@zoolutions.se>
     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

@@ -9,24 +9,19 @@ module SidekiqUniqueJobs
   #   3. worker_class (required, can be anything)
   # @author Mikael Henriksson <mikael@zoolutions.se>
   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,65 @@ 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
+      @lock_type ||= options[LOCK] || item[LOCK] || unique_type
     end
 
+    #
+    # @deprecated in favour of {lock_type}
+    #
+    #
+    # @return [Symbol]
+    #
     def unique_type
-      options[UNIQUE_KEY] || item[UNIQUE_KEY]
+      options[UNIQUE] || item[UNIQUE]
     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