sidekiq-unique-jobs 7.0.8 → 7.1.0

data/lib/sidekiq_unique_jobs/middleware/client.rb

@@ -6,7 +6,12 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Client
+      # 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
@@ -25,18 +30,11 @@ module SidekiqUniqueJobs
       private
 
       def lock
-        if (_token = lock_instance.lock)
-          yield
-        else
-          warn_about_duplicate
+        lock_instance.lock do |_locked_jid|
+          reflect(:locked, item)
+          return yield
         end
       end
-
-      def warn_about_duplicate
-        return unless log_duplicate?
-
-        log_warn "Already locked with another job_id (#{dump_json(item)})"
-      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/middleware/server.rb

@@ -6,6 +6,8 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@mhenrixon.com>
     class Server
+      # prepend "SidekiqUniqueJobs::Middleware"
+      # @!parse prepends SidekiqUniqueJobs::Middleware
       prepend SidekiqUniqueJobs::Middleware
 
       #

data/lib/sidekiq_unique_jobs/on_conflict/reschedule.rb

@@ -9,6 +9,7 @@ module SidekiqUniqueJobs
       include SidekiqUniqueJobs::SidekiqWorkerMethods
       include SidekiqUniqueJobs::Logging
       include SidekiqUniqueJobs::JSON
+      include SidekiqUniqueJobs::Reflectable
 
       # @param [Hash] item sidekiq job hash
       def initialize(item, redis_pool = nil)
@@ -20,10 +21,13 @@ module SidekiqUniqueJobs
       #   This will mess up sidekiq stats because a new job is created
       def call
         if sidekiq_worker_class?
-          log_info("Rescheduling #{item[LOCK_DIGEST]}")
-          worker_class.perform_in(5, *item[ARGS])
+          if worker_class.perform_in(5, *item[ARGS])
+            reflect(:rescheduled, item)
+          else
+            reflect(:reschedule_failed, item)
+          end
         else
-          log_warn("Skip rescheduling of #{item[LOCK_DIGEST]} because #{worker_class} is not a Sidekiq::Worker")
+          reflect(:unknown_sidekiq_worker, item)
         end
       end
     end

data/lib/sidekiq_unique_jobs/options_with_fallback.rb

@@ -29,15 +29,6 @@ module SidekiqUniqueJobs
       !unique_enabled?
     end
 
-    # Should duplicate payloads be logged?
-    #
-    #
-    # @return [true, false, nil]
-    #
-    def log_duplicate?
-      options[LOG_DUPLICATE] || item[LOG_DUPLICATE]
-    end
-
     #
     # A new lock for this Sidekiq Job
     #

data/lib/sidekiq_unique_jobs/orphans/manager.rb

@@ -31,6 +31,7 @@ module SidekiqUniqueJobs
         with_logging_context do
           register_reaper_process
           log_info("Starting Reaper")
+
           task.add_observer(Observer.new)
           task.execute
           task

data/lib/sidekiq_unique_jobs/orphans/reaper_resurrector.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Orphans
+    # Restarts orphan manager if it is considered dead
+    module ReaperResurrector
+      module_function
+
+      include SidekiqUniqueJobs::Connection
+      include SidekiqUniqueJobs::Logging
+
+      DRIFT_FACTOR = 0.1
+      REAPERS = [:ruby, :lua].freeze
+
+      #
+      # Starts reaper resurrector that watches orphans reaper
+      #
+      # @return [SidekiqUniqueJobs::TimerTask] the task that was started
+      #
+      def start
+        return if resurrector_disabled?
+        return if reaper_disabled?
+
+        with_logging_context do
+          run_task
+        end
+      end
+
+      #
+      # Runs reaper resurrector task
+      #
+      # @return [SidekiqUniqueJobs::TimerTask]
+      def run_task
+        log_info("Starting Reaper Resurrector")
+        task.execute
+        task
+      end
+
+      #
+      # The task that runs the resurrector
+      #
+      # @return [SidekiqUniqueJobs::TimerTask]
+      def task
+        SidekiqUniqueJobs::TimerTask.new(timer_task_options) do
+          with_logging_context do
+            restart_if_dead
+          end
+        end
+      end
+
+      #
+      # Starts new instance of orphan reaper if reaper is considered dead (reaper mutex has not been refreshed lately)
+      #
+      def restart_if_dead
+        return if reaper_registered?
+
+        log_info("Reaper is considered dead. Starting new reaper instance")
+        orphans_manager.start
+      end
+
+      #
+      # Returns orphan manager
+      #
+      # @return [SidekiqUniqueJobs::Orphans::Manager]
+      def orphans_manager
+        SidekiqUniqueJobs::Orphans::Manager
+      end
+
+      #
+      # Checks if resurrector is disabled
+      #
+      # @see resurrector_enabled?
+      #
+      # @return [true, false]
+      def resurrector_disabled?
+        !resurrector_enabled?
+      end
+
+      #
+      # Checks if resurrector is enabled
+      #
+      # @return [true, false]
+      def resurrector_enabled?
+        SidekiqUniqueJobs.config.reaper_resurrector_enabled
+      end
+
+      #
+      # Checks if reaping is disabled
+      #
+      # @see reaper_enabled?
+      #
+      # @return [true, false]
+      #
+      def reaper_disabled?
+        !reaper_enabled?
+      end
+
+      #
+      # Checks if reaping is enabled
+      #
+      # @return [true, false]
+      #
+      def reaper_enabled?
+        REAPERS.include?(reaper)
+      end
+
+      #
+      # Checks if reaper is registered
+      #
+      # @return [true, false]
+      def reaper_registered?
+        redis do |conn|
+          conn.get(UNIQUE_REAPER).to_i + drift_reaper_interval > current_timestamp
+        end
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#reaper
+      #
+      def reaper
+        SidekiqUniqueJobs.config.reaper
+      end
+
+      #
+      # Arguments passed on to the timer task
+      #
+      #
+      # @return [Hash]
+      #
+      def timer_task_options
+        { run_now: false,
+          execution_interval: reaper_resurrector_interval }
+      end
+
+      #
+      # A context to use for all log entries
+      #
+      #
+      # @return [Hash] when logger responds to `:with_context`
+      # @return [String] when logger does not responds to `:with_context`
+      #
+      def logging_context
+        if logger_context_hash?
+          { "uniquejobs" => "reaper-resurrector" }
+        else
+          "uniquejobs=reaper-resurrector"
+        end
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#reaper_resurrector_interval
+      #
+      def reaper_resurrector_interval
+        SidekiqUniqueJobs.config.reaper_resurrector_interval
+      end
+
+      def reaper_interval
+        SidekiqUniqueJobs.config.reaper_interval
+      end
+
+      def drift_reaper_interval
+        reaper_interval + (reaper_interval * DRIFT_FACTOR).to_i
+      end
+
+      def current_timestamp
+        Time.now.to_i
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/redis/sorted_set.rb

@@ -26,7 +26,7 @@ module SidekiqUniqueJobs
       #
       # Adds a value to the sorted set
       #
-      # @param [Array<Float, String>, String] the values to add
+      # @param [Array<Float, String>, String] values the values to add
       #
       # @return [Boolean, Integer] <description>
       #

data/lib/sidekiq_unique_jobs/reflectable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Module Reflectable provides a method to notify subscribers
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  module Reflectable
+    def reflect(name, *args)
+      SidekiqUniqueJobs.reflections.dispatch(name, *args)
+      nil
+    rescue UniqueJobsError => ex
+      SidekiqUniqueJobs.logger.error(ex)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/reflections.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  #
+  # Class NotificationCollection provides a collection with known notifications
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  #
+  class Reflections
+    #
+    # @return [Array<Symbol>] list of notifications
+    REFLECTIONS = [
+      :after_unlock_callback_failed,
+      :debug,
+      :duplicate,
+      :error,
+      :execution_failed,
+      :lock_failed,
+      :locked,
+      :reschedule_failed,
+      :rescheduled,
+      :timeout,
+      :unknown_sidekiq_worker,
+      :unlock_failed,
+      :unlocked,
+    ].freeze
+
+    #
+    # @return [Hash<Symbol, Array<Symbol, String>>] a hash with deprecated notifications
+    DEPRECATIONS = {}.freeze
+
+    REFLECTIONS.each do |reflection|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{reflection}(*args, &block)                            # def unlock_failed(*args, &block)
+          raise NoBlockGiven, "block required" unless block_given?  #   raise NoBlockGiven, "block required" unless block_given?
+          @reflections[:#{reflection}] = block                      #   @notifications[:unlock_failed] = block
+        end                                                         # end
+      RUBY
+    end
+
+    def initialize
+      @reflections = {}
+    end
+
+    def dispatch(reflection, *args)
+      if (block = @reflections[reflection])
+        block.call(*args)
+
+        if DEPRECATIONS.key?(reflection)
+          replacement, removal_version = DEPRECATIONS[reflection]
+          SidekiqUniqueJobs::Deprecation.warn(
+            "#{reflection} is deprecated and will be removed in version #{removal_version}. Use #{replacement} instead.",
+          )
+        end
+      elsif misconfigured?(reflection)
+        raise NoSuchNotificationError, reflection
+      end
+    end
+
+    def configured?(reflection)
+      REFLECTIONS.include?(reflection)
+    end
+
+    def misconfigured?(reflection)
+      !configured?(reflection)
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/script/caller.rb

@@ -45,7 +45,9 @@ module SidekiqUniqueJobs
         pool = defined?(redis_pool) ? redis_pool : nil
 
         redis(pool) do |new_conn|
-          do_call(file_name, new_conn, keys, argv)
+          result = do_call(file_name, new_conn, keys, argv)
+          yield result if block_given?
+          result
         end
       end
 

data/lib/sidekiq_unique_jobs/server.rb

@@ -29,6 +29,7 @@ module SidekiqUniqueJobs
       SidekiqUniqueJobs::UpdateVersion.call
       SidekiqUniqueJobs::UpgradeLocks.call
       SidekiqUniqueJobs::Orphans::Manager.start
+      SidekiqUniqueJobs::Orphans::ReaperResurrector.start
     end
 
     def self.stop

data/lib/sidekiq_unique_jobs/sidekiq_unique_jobs.rb

@@ -4,7 +4,7 @@
 # Contains configuration and utility methods that belongs top level
 #
 # @author Mikael Henriksson <mikael@mhenrixon.com>
-module SidekiqUniqueJobs
+module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
   include SidekiqUniqueJobs::Connection
   extend SidekiqUniqueJobs::JSON
 
@@ -236,4 +236,59 @@ module SidekiqUniqueJobs
     lock_config = validate_worker(options)
     raise InvalidWorker, lock_config unless lock_config.errors.empty?
   end
+
+  # Attempt to constantize a string worker_class argument, always
+  # failing back to the original argument when the constant can't be found
+  #
+  # @return [Sidekiq::Worker]
+  def constantize(str)
+    return str.class             if str.is_a?(Sidekiq::Worker) # sidekiq v6.x
+    return str                   unless str.is_a?(String)
+    return Object.const_get(str) unless str.include?("::")
+
+    names = str.split("::")
+    names.shift if names.empty? || names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      # the false flag limits search for name to under the constant namespace
+      #   which mimics Rails' behaviour
+      constant.const_get(name, false)
+    end
+  end
+
+  # Attempt to constantize a string worker_class argument, always
+  # failing back to the original argument when the constant can't be found
+  #
+  # @return [Sidekiq::Worker, String]
+  def safe_constantize(str)
+    constantize(str)
+  rescue NameError => ex
+    case ex.message
+    when /uninitialized constant/
+      str
+    else
+      raise
+    end
+  end
+
+  #
+  # Collection with notifications
+  #
+  #
+  # @return [Reflections]
+  #
+  def reflections
+    @reflections ||= Reflections.new
+  end
+
+  #
+  # Yields notification stack for sidekiq unique jobs to configure notifications
+  #
+  #
+  # @return [void] <description>
+  #
+  # @yieldparam [Reflections] x used to configure notifications
+  def reflect
+    yield reflections if block_given?
+  end
 end