sidekiq-unique-jobs 6.0.7 → 7.1.33

data/lib/sidekiq_unique_jobs/middleware/client.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Middleware
+    # The unique sidekiq middleware for the client push
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Client
+      include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+      # prepend "SidekiqUniqueJobs::Middleware"
+      # @!parse prepends SidekiqUniqueJobs::Middleware
+      prepend SidekiqUniqueJobs::Middleware
+      # includes "SidekiqUniqueJobs::Reflectable"
+      # @!parse include SidekiqUniqueJobs::Reflectable
+      include SidekiqUniqueJobs::Reflectable
+
+      # Calls this client middleware
+      #   Used from Sidekiq.process_single
+      #
+      # @see SidekiqUniqueJobs::Middleware#call
+      #
+      # @see https://github.com/mperham/sidekiq/wiki/Job-Format
+      # @see https://github.com/mperham/sidekiq/wiki/Middleware
+      #
+      # @yield when uniqueness is disable
+      # @yield when the lock is successful
+      def call(*, &block)
+        lock(&block)
+      end
+
+      private
+
+      def lock
+        lock_instance.lock do
+          reflect(:locked, item)
+          return yield
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/middleware/server.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Middleware
+    # The unique sidekiq middleware for the server processor
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Server
+      include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+      # prepend "SidekiqUniqueJobs::Middleware"
+      # @!parse prepends SidekiqUniqueJobs::Middleware
+      prepend SidekiqUniqueJobs::Middleware
+
+      #
+      #
+      # Runs the server middleware (used from Sidekiq::Processor#process)
+      #
+      # @see SidekiqUniqueJobs::Middleware#call
+      #
+      # @see https://github.com/mperham/sidekiq/wiki/Job-Format
+      # @see https://github.com/mperham/sidekiq/wiki/Middleware
+      #
+      # @yield when uniqueness is disabled
+      # @yield when owning the lock
+      def call(*, &block)
+        lock_instance.execute(&block)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/middleware.rb

@@ -1,42 +1,45 @@
 # frozen_string_literal: true
 
-require 'sidekiq'
-
 module SidekiqUniqueJobs
+  #
+  # Provides the sidekiq middleware that makes the gem work
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
   module Middleware
-    def self.extended(base)
-      base.class_eval do
-        configure_middleware
-      end
-    end
+    include SidekiqUniqueJobs::Logging::Middleware
+    include SidekiqUniqueJobs::OptionsWithFallback
+    include SidekiqUniqueJobs::JSON
 
-    def configure_middleware
-      configure_server_middleware
-      configure_client_middleware
-    end
+    # The sidekiq job hash
+    # @return [Hash] the Sidekiq job hash
+    attr_reader :item
 
-    def configure_server_middleware
-      Sidekiq.configure_server do |config|
-        config.client_middleware do |chain|
-          require 'sidekiq_unique_jobs/client/middleware'
-          chain.add SidekiqUniqueJobs::Client::Middleware
-        end
+    #
+    # This method runs before (prepended) the actual middleware implementation.
+    #   This is done to reduce duplication
+    #
+    # @param [Sidekiq::Worker] worker_class
+    # @param [Hash] item a sidekiq job hash
+    # @param [String] queue name of the queue
+    # @param [ConnectionPool] redis_pool only used for compatility reasons
+    #
+    # @return [yield<super>] <description>
+    #
+    # @yieldparam [<type>] if <description>
+    # @yieldreturn [<type>] <describe what yield should return>
+    def call(worker_class, item, queue, redis_pool = nil)
+      @item       = item
+      @queue      = queue
+      @redis_pool = redis_pool
+      self.job_class = worker_class
+      return yield if unique_disabled?
 
-        config.server_middleware do |chain|
-          require 'sidekiq_unique_jobs/server/middleware'
-          chain.add SidekiqUniqueJobs::Server::Middleware
-        end
-      end
-    end
+      SidekiqUniqueJobs::Job.prepare(item) unless item[LOCK_DIGEST]
 
-    def configure_client_middleware
-      Sidekiq.configure_client do |config|
-        config.client_middleware do |chain|
-          require 'sidekiq_unique_jobs/client/middleware'
-          chain.add SidekiqUniqueJobs::Client::Middleware
-        end
+      with_logging_context do
+        super
       end
     end
   end
 end
-SidekiqUniqueJobs.send(:extend, SidekiqUniqueJobs::Middleware)

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>
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
   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/log.rb

@@ -4,16 +4,20 @@ module SidekiqUniqueJobs
   module OnConflict
     # Strategy to log information about conflict
     #
-    # @author Mikael Henriksson <mikael@zoolutions.se>
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
     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 lock_digest: (#{item[LOCK_DIGEST]}) already exists
+        MESSAGE
       end
     end
   end

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,13 +4,13 @@ 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
       # @raise [SidekiqUniqueJobs::Conflict]
       def call
-        fail SidekiqUniqueJobs::Conflict, item
+        raise SidekiqUniqueJobs::Conflict, item
       end
     end
   end

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|
-          conn.multi do
-            conn.zadd('dead', current_time, payload)
-            conn.zremrangebyscore('dead', '-inf', current_time - Sidekiq::DeadSet.timeout)
-            conn.zremrangebyrank('dead', 0, -Sidekiq::DeadSet.max_jobs)
+        redis do |conn|
+          conn.multi do |pipeline|
+            pipeline.zadd("dead", now_f, payload)
+            pipeline.zremrangebyscore("dead", "-inf", now_f - Sidekiq::DeadSet.timeout)
+            pipeline.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
-        Scripts.call(:delete_by_digest, nil, keys: [UNIQUE_SET, 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,31 @@ 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
+      include SidekiqUniqueJobs::Reflectable
 
       # @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)
+        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
-        worker_class&.perform_in(5, *item[ARGS_KEY]) if sidekiq_worker_class?
+        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)
+          end
+        else
+          reflect(:unknown_sidekiq_worker, item)
+        end
       end
     end
   end

data/lib/sidekiq_unique_jobs/on_conflict/strategy.rb

@@ -5,25 +5,44 @@ 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
       # @raise [NotImplementedError] needs to be implemented in child class
       def call
-        fail NotImplementedError, 'needs to be implemented in child class'
+        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/on_conflict.rb

@@ -1,26 +1,44 @@
 # frozen_string_literal: true
 
-require_relative 'on_conflict/strategy'
-require_relative 'on_conflict/null_strategy'
-require_relative 'on_conflict/log'
-require_relative 'on_conflict/raise'
-require_relative 'on_conflict/reject'
-require_relative 'on_conflict/replace'
-require_relative 'on_conflict/reschedule'
+require_relative "on_conflict/strategy"
+require_relative "on_conflict/null_strategy"
+require_relative "on_conflict/log"
+require_relative "on_conflict/raise"
+require_relative "on_conflict/reject"
+require_relative "on_conflict/replace"
+require_relative "on_conflict/reschedule"
 
 module SidekiqUniqueJobs
+  #
+  # Provides lock conflict resolutions
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
   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