resque-unique_by_arity 3.0.2 → 3.0.3

data/lib/resque/unique_by_arity/configuration/validator.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Resque
+  module UniqueByArity
+    class Configuration
+      class Validator
+        extend Forwardable
+
+        ARITY_FOR_UNIQUENESS_MSG = "[%<job_name>s] :arity_for_uniqueness is set to %<arity_for_uniqueness>d, but no uniqueness enforcement was turned on [:unique_at_runtime, :unique_in_queue, :unique_across_queues]"
+        ARITY_FOR_UNIQUENESS_AT_RUNTIME_MSG = "[%<job_name>s] :arity_for_uniqueness_at_runtime is set to %<arity_for_uniqueness_at_runtime>d, but :unique_at_runtime was not turned on"
+        ARITY_FOR_UNIQUENESS_IN_QUEUE_MSG = "[%<job_name>s] :arity_for_uniqueness_in_queue is set to %<arity_for_uniqueness_in_queue>d, but :unique_in_queue was not turned on"
+        ARITY_FOR_UNIQUENESS_ACROSS_QUEUES_MSG = "[%<job_name>s] :arity_for_uniqueness_across_queues is set to %<arity_for_uniqueness_across_queues>d, but :unique_across_queues was not turned on"
+        LOCK_AFTER_EXEC_PERIOD_MSG = "[%<job_name>s] :lock_after_execution_period is set to %<lock_after_execution_period>d, but :unique_at_runtime is not set"
+        RUNTIME_LOCK_TIMEOUT_MSG = "[%<job_name>s] :runtime_lock_timeout is set to %<runtime_lock_timeout>s, but :unique_at_runtime is not set"
+        RUNTIME_REQUEUE_INTERVAL_MSG = "[%<job_name>s] :runtime_requeue_interval is set to %<runtime_requeue_interval>d, but :unique_at_runtime is not set"
+        CONCURRENT_CONFIG_MSG = "[%<job_name>] :unique_in_queue and :unique_across_queues should not be set at the same time, as :unique_across_queues will always supercede :unique_in_queue"
+
+        private_constant :ARITY_FOR_UNIQUENESS_MSG,
+          :ARITY_FOR_UNIQUENESS_AT_RUNTIME_MSG,
+          :ARITY_FOR_UNIQUENESS_IN_QUEUE_MSG,
+          :ARITY_FOR_UNIQUENESS_ACROSS_QUEUES_MSG,
+          :LOCK_AFTER_EXEC_PERIOD_MSG,
+          :RUNTIME_LOCK_TIMEOUT_MSG,
+          :RUNTIME_REQUEUE_INTERVAL_MSG,
+          :CONCURRENT_CONFIG_MSG
+
+        def initialize(config)
+          @config = config
+        end
+
+        def log_warnings
+          validate_arity_for_uniqueness
+          validate_arity_for_uniqueness_at_runtime
+          validate_arity_for_uniqueness_in_queue
+          validate_arity_for_uniqueness_across_queues
+          validate_after_execution_period
+          validate_runtime_lock_timout
+          validate_runtime_requeue_interval
+        end
+
+        def self.log_warnings(*args)
+          new(*args).log_warnings
+        end
+
+        private
+
+        attr_reader :config
+        def_delegators :config,
+          :arity_for_uniqueness,
+          :arity_for_uniqueness_at_runtime,
+          :arity_for_uniqueness_in_queue,
+          :arity_for_uniqueness_across_queues,
+          :base_klass_name,
+          :lock_after_execution_period,
+          :runtime_lock_timeout,
+          :runtime_requeue_interval,
+          :unique_across_queues,
+          :unique_at_runtime,
+          :unique_in_queue
+
+        def log(msg)
+          Resque::UniqueByArity.log(msg, config)
+        end
+
+        def default_config_value?(config_attr)
+          config.send(config_attr) == default_config(config_attr)
+        end
+
+        def default_config(attr)
+          Resque::UniqueByArity.configuration.send(attr)
+        end
+
+        def validate_runtime_requeue_interval
+          return if default_config_value?(:runtime_requeue_interval) ||
+            unique_at_runtime
+
+          log format(
+            RUNTIME_REQUEUE_INTERVAL_MSG,
+            job_name: base_klass_name,
+            runtime_requeue_interval: runtime_requeue_interval
+          )
+        end
+
+        def validate_runtime_lock_timout
+          return if default_config_value?(:runtime_lock_timeout) ||
+            unique_at_runtime
+
+          log format(
+            RUNTIME_LOCK_TIMEOUT_MSG,
+            job_name: base_klass_name,
+            runtime_lock_timeout: runtime_lock_timeout
+          )
+        end
+
+        def validate_after_execution_period
+          return if default_config_value?(:lock_after_execution_period) ||
+            (unique_in_queue || unique_across_queues)
+
+          log format(
+            LOCK_AFTER_EXEC_PERIOD_MSG,
+            job_name: base_klass_name,
+            lock_after_execution_period: lock_after_execution_period
+          )
+        end
+
+        def validate_arity_for_uniqueness
+          return if arity_for_uniqueness == 1 ||
+            (unique_at_runtime ||
+             unique_in_queue ||
+             unique_across_queues)
+
+          log format(
+            ARITY_FOR_UNIQUENESS_MSG,
+            job_name: base_klass_name,
+            arity_for_uniqueness: arity_for_uniqueness
+          )
+        end
+
+        def validate_arity_for_uniqueness_at_runtime
+          return if arity_for_uniqueness_at_runtime == arity_for_uniqueness || unique_at_runtime
+
+          log format(
+            ARITY_FOR_UNIQUENESS_AT_RUNTIME_MSG,
+            job_name: base_klass_name,
+            arity_for_uniqueness_at_runtime: arity_for_uniqueness_at_runtime
+          )
+        end
+
+        def validate_arity_for_uniqueness_in_queue
+          return if arity_for_uniqueness_in_queue == arity_for_uniqueness || unique_in_queue
+
+          log format(
+            ARITY_FOR_UNIQUENESS_IN_QUEUE_MSG,
+            job_name: base_klass_name,
+            arity_for_uniqueness_in_queue: arity_for_uniqueness_in_queue
+          )
+        end
+
+        def validate_arity_for_uniqueness_across_queues
+          return if arity_for_uniqueness_across_queues == arity_for_uniqueness || unique_across_queues
+
+          log format(
+            ARITY_FOR_UNIQUENESS_ACROSS_QUEUES_MSG,
+            job_name: base_klass_name,
+            arity_for_uniqueness_across_queues: arity_for_uniqueness_across_queues
+          )
+        end
+      end
+    end
+  end
+end

data/lib/resque/unique_by_arity/configuration.rb

@@ -1,4 +1,4 @@
-require 'logger'
+require "logger"
 module Resque
   module UniqueByArity
     # This class is for configurations that are per job class, *not* app-wide.
@@ -11,6 +11,9 @@ module Resque
       attr_accessor :logger
       attr_accessor :log_level
       attr_accessor :arity_for_uniqueness
+      attr_accessor :arity_for_uniqueness_at_runtime
+      attr_accessor :arity_for_uniqueness_in_queue
+      attr_accessor :arity_for_uniqueness_across_queues
       attr_accessor :arity_validation
       attr_accessor :lock_after_execution_period
       attr_accessor :runtime_lock_timeout
@@ -28,6 +31,9 @@ module Resque
         @logger = options.key?(:logger) ? options[:logger] : defcon(:logger) || Logger.new(STDOUT)
         @log_level = options.key?(:log_level) ? options[:log_level] : defcon(:log_level) || :debug
         @arity_for_uniqueness = options.key?(:arity_for_uniqueness) ? options[:arity_for_uniqueness] : defcon(:arity_for_uniqueness) || 1
+        @arity_for_uniqueness_at_runtime = options.key?(:arity_for_uniqueness_at_runtime) ? options[:arity_for_uniqueness_at_runtime] : defcon(:arity_for_uniqueness_at_runtime) || @arity_for_uniqueness
+        @arity_for_uniqueness_in_queue = options.key?(:arity_for_uniqueness_in_queue) ? options[:arity_for_uniqueness_in_queue] : defcon(:arity_for_uniqueness_in_queue) || @arity_for_uniqueness
+        @arity_for_uniqueness_across_queues = options.key?(:arity_for_uniqueness_across_queues) ? options[:arity_for_uniqueness_across_queues] : defcon(:arity_for_uniqueness_across_queues) || @arity_for_uniqueness
         @arity_validation = options.key?(:arity_validation) ? options[:arity_validation] : defcon(:arity_validation) || :warning
         raise ArgumentError, "Resque::Plugins::UniqueByArity.new requires arity_validation values of #{arity_validation.inspect}, or a class inheriting from Exception, but the value is #{@arity_validation} (#{@arity_validation.class})" unless VALID_ARITY_VALIDATION_LEVELS.include?(@arity_validation) || !@arity_validation.respond_to?(:ancestors) || @arity_validation.ancestors.include?(Exception)
 
@@ -52,14 +58,9 @@ module Resque
       end
 
       def validate
-        # The default config initialization shouldn't trigger any warnings.
-        if base_klass_name && logger
-          log "[#{base_klass_name}] :arity_for_uniqueness is set to #{arity_for_uniqueness}, but no uniqueness enforcement was turned on [:unique_at_runtime, :unique_in_queue, :unique_across_queues]" unless unique_at_runtime || unique_in_queue || unique_across_queues
-          log "[#{base_klass_name}] :lock_after_execution_period is set to #{lock_after_execution_period}, but :unique_at_runtime is not set" if lock_after_execution_period && !(unique_in_queue || unique_across_queues)
-          log "[#{base_klass_name}] :runtime_lock_timeout is set to #{runtime_lock_timeout}, but :unique_at_runtime is not set" if runtime_lock_timeout && !unique_at_runtime
-          log "[#{base_klass_name}] :runtime_requeue_interval is set to #{runtime_requeue_interval}, but :unique_at_runtime is not set" if runtime_requeue_interval && !unique_at_runtime
-          log "[#{base_klass_name}] :unique_in_queue and :unique_across_queues should not be set at the same time, as :unique_across_queues will always supercede :unique_in_queue" if unique_in_queue && unique_across_queues
-        end
+        return unless base_klass_name && logger
+
+        Validator.log_warnings(self)
       end
 
       def log(msg)
@@ -71,6 +72,9 @@ module Resque
           log_level: log_level,
           logger: logger,
           arity_for_uniqueness: arity_for_uniqueness,
+          arity_for_uniqueness_at_runtime: arity_for_uniqueness_at_runtime,
+          arity_for_uniqueness_in_queue: arity_for_uniqueness_in_queue,
+          arity_for_uniqueness_across_queues: arity_for_uniqueness_across_queues,
           arity_validation: arity_validation,
           base_klass_name: base_klass_name,
           debug_mode: debug_mode,
@@ -99,25 +103,25 @@ module Resque
         #   for perform(opts = {}), method(:perform).arity # => -1
         #   which means that the only valid arity_for_uniqueness is 0
         msg = if perform_method.arity >= 0
-                # takes a fixed number of arguments
-                # parform(a, b, c) # => arity == 3, so arity for uniqueness can be 0, 1, 2, or 3
-                if perform_method.arity < arity_for_uniqueness
-                  "#{klass_string}.#{perform_method.name} has arity of #{perform_method.arity} which will not work with arity_for_uniqueness of #{arity_for_uniqueness}"
-                end
-              else
-                if perform_method.arity.abs < arity_for_uniqueness
-                  # parform(a, b, c, opts = {}) # => arity == -4
-                  #   and in this case arity for uniqueness can be 0, 1, 2, or 3, because 4 of the arguments are required
-                  "#{klass_string}.#{perform_method.name} has arity of #{perform_method.arity} which will not work with arity_for_uniqueness of #{arity_for_uniqueness}"
-                elsif (required_parameter_names = perform_method.parameters.take_while { |a| a[0] == :req }.map { |b| b[1] }).length < arity_for_uniqueness
-                  "#{klass_string}.#{perform_method.name} has the following required parameters: #{required_parameter_names}, which is not enough to satisfy the configured arity_for_uniqueness of #{arity_for_uniqueness}"
-                end
-              end
+          # takes a fixed number of arguments
+          # parform(a, b, c) # => arity == 3, so arity for uniqueness can be 0, 1, 2, or 3
+          if perform_method.arity < arity_for_uniqueness
+            "#{klass_string}.#{perform_method.name} has arity of #{perform_method.arity} which will not work with arity_for_uniqueness of #{arity_for_uniqueness}"
+          end
+        else
+          if perform_method.arity.abs < arity_for_uniqueness
+            # parform(a, b, c, opts = {}) # => arity == -4
+            #   and in this case arity for uniqueness can be 0, 1, 2, or 3, because 4 of the arguments are required
+            "#{klass_string}.#{perform_method.name} has arity of #{perform_method.arity} which will not work with arity_for_uniqueness of #{arity_for_uniqueness}"
+          elsif (required_parameter_names = perform_method.parameters.take_while { |a| a[0] == :req }.map { |b| b[1] }).length < arity_for_uniqueness
+            "#{klass_string}.#{perform_method.name} has the following required parameters: #{required_parameter_names}, which is not enough to satisfy the configured arity_for_uniqueness of #{arity_for_uniqueness}"
+          end
+        end
         if msg
           case arity_validation
-          when :warning then
-            log(ColorizedString[msg].red)
-          when :error then
+          when :warning
+            log(msg)
+          when :error
             raise ArgumentError, msg
           else
             raise arity_validation, msg
@@ -136,8 +140,8 @@ module Resque
       private
 
       def debug_mode_from_env
-        env_debug = ENV['RESQUE_DEBUG']
-        @debug_mode = !!(env_debug == 'true' || (env_debug.is_a?(String) && env_debug.match?(/queue/)))
+        env_debug = ENV["RESQUE_DEBUG"]
+        @debug_mode = !!(env_debug == "true" || (env_debug.is_a?(String) && env_debug.match?(/queue/)))
       end
     end
   end

data/lib/resque/unique_by_arity/global_configuration.rb

@@ -1,4 +1,4 @@
-require 'logger'
+require "logger"
 module Resque
   module UniqueByArity
     # This class is for configurations that are app-wide, *not per job class.
@@ -10,12 +10,12 @@ module Resque
       # For resque-unique_at_runtime
       DEFAULT_LOCK_TIMEOUT = 60 * 60 * 24 * 5
       DEFAULT_REQUEUE_INTERVAL = 1
-      DEFAULT_AT_RUNTIME_KEY_BASE = 'r-uar'.freeze
+      DEFAULT_AT_RUNTIME_KEY_BASE = "r-uar".freeze
 
       # For resque-unique_in_queue
       DEFAULT_LOCK_AFTER_EXECUTION_PERIOD = 0
       DEFAULT_TTL = -1
-      DEFAULT_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
+      DEFAULT_IN_QUEUE_KEY_BASE = "r-uiq".freeze
 
       include Singleton
 
@@ -24,7 +24,7 @@ module Resque
       end
 
       def defcon(sym)
-        self.send(sym)
+        send(sym)
       end
 
       def reset
@@ -32,6 +32,9 @@ module Resque
         @logger = nil
         @log_level = DEFAULT_LOG_LEVEL
         @arity_for_uniqueness = nil
+        @arity_for_uniqueness_at_runtime = nil
+        @arity_for_uniqueness_in_queue = nil
+        @arity_for_uniqueness_across_queues = nil
         @arity_validation = nil
         @lock_after_execution_period = DEFAULT_LOCK_AFTER_EXECUTION_PERIOD
         @runtime_lock_timeout = DEFAULT_LOCK_TIMEOUT

data/lib/resque/unique_by_arity/modulizer.rb

@@ -5,26 +5,28 @@ module Resque
         Module.new do
           if configuration.unique_in_queue || configuration.unique_at_runtime || configuration.unique_across_queues
             # @return [Array<String, arguments>] the key base hash used to enforce uniqueness, and the arguments from the payload used to calculate it
-            define_method(:redis_unique_hash) do |payload|
+            define_method(:redis_unique_hash) do |payload, arity_for_uniqueness|
+              arity_for_uniqueness ||= configuration.arity_for_uniqueness
               payload = Resque.decode(Resque.encode(payload))
               Resque::UniqueByArity.debug("payload is #{payload.inspect}")
-              job  = payload['class']
+              job = payload["class"]
               # It seems possible that some jobs may not have an "args" key in the payload.
-              args = payload['args'] || []
+              args = payload["args"] || []
               args.map! do |arg|
                 arg.is_a?(Hash) ? arg.sort : arg
               end
+
               # what is the configured arity for uniqueness?
-              uniqueness_args = if configuration.arity_for_uniqueness.zero?
-                                  []
-                                else
-                                  # minus one because zero indexed, so
-                                  #   when arity_for_uniqueness is 2 we use args
-                                  #   at indexes 0 and 1.
-                                  args[0..(configuration.arity_for_uniqueness - 1)]
-                                end
-              args = { class: job, args: uniqueness_args }
-              return [Digest::MD5.hexdigest(Resque.encode(args)), uniqueness_args]
+              uniqueness_args = if arity_for_uniqueness.zero?
+                []
+              else
+                # minus one because zero indexed, so
+                #   when arity_for_uniqueness is 2 we use args
+                #   at indexes 0 and 1.
+                args[0..(arity_for_uniqueness - 1)]
+              end
+              args = {class: job, args: uniqueness_args}
+              [Digest::MD5.hexdigest(Resque.encode(args)), uniqueness_args]
             end
           end
 
@@ -45,9 +47,14 @@ module Resque
             #   a hash containing :class and :args
             # @return [String] the key used to enforce uniqueness (at queue-time)
             define_method(:unique_in_queue_redis_key) do |queue, payload|
-              unique_hash, args_for_uniqueness = redis_unique_hash(payload)
+              arity_for_uniqueness = if configuration.unique_in_queue
+                configuration.arity_for_uniqueness_in_queue
+              elsif configuration.unique_across_queues
+                configuration.arity_for_uniqueness_across_queues
+              end
+              unique_hash, args_for_uniqueness = redis_unique_hash(payload, arity_for_uniqueness)
               key = "#{unique_in_queue_key_namespace(queue)}:#{unique_in_queue_redis_key_prefix}:#{unique_hash}"
-              Resque::UniqueByArity.debug("#{self}.unique_in_queue_redis_key for #{args_for_uniqueness} is: #{ColorizedString[key].green}")
+              Resque::UniqueByArity.debug("#{self}.unique_in_queue_redis_key for #{args_for_uniqueness} is: #{key}")
               key
             end
             #
@@ -56,7 +63,7 @@ module Resque
               # unique_in_queue_key_namespace may or may not ignore the queue passed in, depending on config.
               key_match = "#{unique_in_queue_key_namespace(instance_variable_get(:@queue))}:#{unique_in_queue_redis_key_prefix}:*"
               keys = Resque.redis.keys(key_match)
-              Resque::UniqueByArity.log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueInQueue::PLUGIN_TAG} #{ColorizedString['Purging'].red} #{keys.length} keys from #{ColorizedString[key_match].red}")
+              Resque::UniqueByArity.log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueInQueue::PLUGIN_TAG} Purging #{keys.length} keys from #{key_match}")
               Resque.redis.del keys unless keys.empty?
             end
 
@@ -89,16 +96,16 @@ module Resque
             #   still funnels down to redis_key, and we handle the arity option there
             # @return [String] the key used to enforce loneliness (uniqueness at runtime)
             define_method(:unique_at_runtime_redis_key) do |*args|
-              unique_hash, args_for_uniqueness = redis_unique_hash('class' => to_s, 'args' => args)
+              unique_hash, args_for_uniqueness = redis_unique_hash({"class" => to_s, "args" => args}, configuration.arity_for_uniqueness_at_runtime)
               key = "#{runtime_key_namespace}:#{unique_hash}"
-              Resque::UniqueByArity.debug("#{Resque::UniqueAtRuntime::PLUGIN_TAG} #{self}.unique_at_runtime_redis_key for #{args_for_uniqueness} is: #{ColorizedString[key].yellow}")
+              Resque::UniqueByArity.debug("#{Resque::UniqueAtRuntime::PLUGIN_TAG} #{self}.unique_at_runtime_redis_key for #{args_for_uniqueness} is: #{key}")
               key
             end
             # @return [Fixnum] number of keys that were deleted
             define_method(:purge_unique_at_runtime_redis_keys) do
               key_match = "#{runtime_key_namespace}:*"
               keys = Resque.redis.keys(key_match)
-              Resque::UniqueByArity.log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueAtRuntime::PLUGIN_TAG} #{ColorizedString['Purging'].red} #{keys.length} keys from #{ColorizedString[key_match].red}")
+              Resque::UniqueByArity.log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueAtRuntime::PLUGIN_TAG} Purging #{keys.length} keys from #{key_match}")
               Resque.redis.del keys unless keys.empty?
             end
           end

data/lib/resque/unique_by_arity/version.rb

@@ -1,5 +1,13 @@
+# frozen_string_literal: true
+
 module Resque
   module UniqueByArity
-    VERSION = '3.0.2'.freeze
+    # Version namespace for this gem.
+    module Version
+      # Current gem version.
+      VERSION = "3.0.3"
+    end
+    # Current gem version exposed at the traditional constant location.
+    VERSION = Version::VERSION # Traditional Constant Location
   end
 end

data/lib/resque/unique_by_arity.rb

@@ -1,9 +1,11 @@
 # Just in case some code still does require 'resque/unique_by_arity'
-require 'resque-unique_by_arity'
+
+require "resque-unique_by_arity"
+require_relative "unique_by_arity/version"
 
 module Resque
   module UniqueByArity
-    PLUGIN_TAG = (ColorizedString['[R-UBA] '].green).freeze
+    PLUGIN_TAG = "[R-UBA] ".freeze
 
     def log(message, config_proxy = nil)
       config_proxy ||= configuration

data/lib/resque-unique_by_arity.rb

@@ -1,17 +1,17 @@
-require 'resque/unique_by_arity/version'
+require "resque/unique_by_arity/version"
 
 # External Gems
-require 'colorized_string'
-require 'resque'
+require "resque"
 
 # External Resque Plugins
-require 'resque-unique_in_queue'
-require 'resque-unique_at_runtime'
+require "resque-unique_in_queue"
+require "resque-unique_at_runtime"
 
-require 'resque/unique_by_arity/configuration'
-require 'resque/unique_by_arity/global_configuration'
-require 'resque/unique_by_arity'
-require 'resque/unique_by_arity/modulizer'
-require 'resque/unique_by_arity/unique_job'
-require 'resque/unique_by_arity/validation'
-require 'resque/plugins/unique_by_arity'
+require "resque/unique_by_arity/configuration"
+require "resque/unique_by_arity/configuration/validator"
+require "resque/unique_by_arity/global_configuration"
+require "resque/unique_by_arity"
+require "resque/unique_by_arity/modulizer"
+require "resque/unique_by_arity/unique_job"
+require "resque/unique_by_arity/validation"
+require "resque/plugins/unique_by_arity"

data/sig/resque/unique_by_arity.rbs

@@ -0,0 +1,8 @@
+module Resque
+  module UniqueByArity
+    module Version
+      VERSION: String
+    end
+    VERSION: String
+  end
+end