resque-unique_by_arity 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2832d3ab2ddbac6a32f3402a0a24dea7eb8ca6b253d0eff6ea6f8a924e343fb1
-  data.tar.gz: a03a10a39c8fe8b1bfbec33299b4de7a72f7d8da3e8d1131c693e97fb61cc580
+  metadata.gz: bfe4371869efe4deb3aed04f46d2417ab32c82e4fadc7954d6d79a0e9cbbe8d2
+  data.tar.gz: 7b8392ab635f8acc02c6e0d9fa09fe79fd287099ede2f75fd654c43661ab161d
 SHA512:
-  metadata.gz: bdd1c1ff4d5ba5aca5ba17f3e6ae290c349f7064084c0876054200a28951352b410163287db536d0930109d655c7a43c51b61271bdc972d4dc65436fc85bc772
-  data.tar.gz: dc859b3415561ec698bb82381c713cef59f298c8ae591ff281eef103b0b545b5dec7e30de45c58c41d5e9415b2e289b046312ec8335b887ff1fb7baae274c027
+  metadata.gz: 8e93042522fa854d08126b163847f5fb670321da013f1e7c20a179311aaf7e0c621855d8998cb465e96df38057a7aaa45357cba36caea1ebc035972a65f17727
+  data.tar.gz: 8a9033f210f024ef2cf99805a97e87137b585dbc6ad82ba58c410b2b6dd7d6021cf2f33af84647a85f4aa9c182ef76830674afa81628c5bbd046625efcb3558e

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+.rspec_status

data/Gemfile

@@ -2,8 +2,8 @@ source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
-gem 'resque-unique_in_queue'
-gem 'resque-unique_at_runtime'
+gem 'resque-unique_in_queue', path: '/Users/pboling/Documents/code/intricately/resque-unique_in_queue'
+gem 'resque-unique_at_runtime', path: '/Users/pboling/Documents/code/intricately/resque-unique_at_runtime'
 
 group :test do
   unless ENV['TRAVIS']

data/README.md

@@ -1,11 +1,18 @@
 # Resque::UniqueByArity
 
-Because some jobs have parameters that you do not want to consider for determination of uniqueness.
+Because some jobs have parameters that you do not want to consider for 
+determination of uniqueness.
 
 NOTE:
 
-Requires `resque_solo` gem, and `resque-unique_by_arity` gem; the latter is a fork of `resque-lonely_job`.
-Why? `resque-lonely_job` and `resque_solo` can't be used together, because their `redis_key` methods conflict.
+I rewrote, and renamed, both `resque_solo` and `resque-lonely_job`, becuase they
+ can't be used together.  Why?  Their `redis_key` methods directly conflict, 
+ among other more subtle issues.
+
+This gem requires use of my rewritten gems for uniqueness enforcement:
+
+  - [`resque-unique_at_runtime`](https://github.com/pboling/resque-unique_at_runtime)
+  - [`resque-unique_in_queue`](https://github.com/pboling/resque-unique_in_queue)
 
 | Project                 |  Resque::UniqueByArity |
 |------------------------ | ----------------------- |
@@ -24,11 +31,13 @@ Why? `resque-lonely_job` and `resque_solo` can't be used together, because their
 
 ## Important Note
 
-See `lib/resque/unique_by_arity/configuration.rb` for all config options.  Only a smattering of what is available is documented in this README.
+See `lib/resque/unique_by_arity/configuration.rb` for all config options.  Only
+ a smattering of what is available is documented in this README.
 
 ## Most Important Note
 
-You must configure this gem *after* you define the perform class method in your job or an error will be raised thanks to `perform` not having been defined yet.
+You must configure this gem *after* you define the perform class method in your
+ job or an error will be raised thanks to `perform` not having been defined yet.
 
 Example:
 
@@ -65,9 +74,44 @@ Or install it yourself as:
 
 ## Usage
 
+This gem will take care to set the class instance variables (similar to the
+ familiar `@queue` class instance variable) that are utilized by 
+ `resque-unique_in_queue` and `resque-unique_at_runtime` (default values shown):
+
+ ```ruby
+# For resque-unique_at_runtime
+@runtime_lock_timeout = 60 * 60 * 24 * 5
+@runtime_requeue_interval = 1
+@unique_at_runtime_key_base = 'r-uar'.freeze
+
+# For resque-unique_in_queue
+@lock_after_execution_period = 0
+@ttl = -1
+@unique_in_queue_key_base = 'r-uiq'.freeze
+```
+
+All you need to do is configure this gem accordingly:
+```ruby
+  include Resque::Plugins::UniqueByArity.new(
+    arity_for_uniqueness: 3,
+    unique_at_runtime: true,
+    unique_in_queue: true,
+    # No need to do the following if keeping default values
+    runtime_lock_timeout: 60 * 60 * 24 * 5,
+    runtime_requeue_interval: 1,
+    unique_at_runtime_key_base: 'r-uar'.freeze,
+    lock_after_execution_period: 0,
+    ttl: 0,
+    unique_in_queue_key_base: 'r-uiq'.freeze
+  )
+```
+
 ### Arity For Uniqueness
 
-Some jobs have parameters that you do not want to consider for determination of uniqueness.  Resque jobs should use simple parameters, **not named parameters**, so you can just specify the number of parameters, counting from the left, you want to be considered for uniqueness.
+Some jobs have parameters that you do not want to consider for determination of
+ uniqueness.  Resque jobs should use simple parameters, **not named parameters**,
+  so you can just specify the number of parameters, counting from the left, you
+   want to be considered for uniqueness.
 
 ```ruby
 class MyJob
@@ -105,7 +149,8 @@ end
 
 ### Lock After Execution
 
-Give the job a break after it finishes running, and don't allow another of the same, with matching args @ configured arity, to start within X seconds.
+Give the job a break after it finishes running, and don't allow another of the
+ same, with matching args @ configured arity, to start within X seconds.
 
 ```ruby
 class MyJob
@@ -122,7 +167,8 @@ end
 
 ### Runtime Lock Timeout
 
-If runtime lock keys get stale, they will expire on their own after some period.  You can set the expiration period on a per class basis.
+If runtime lock keys get stale, they will expire on their own after some period.
+  You can set the expiration period on a per class basis.
 
 ```ruby
 class MyJob
@@ -263,7 +309,8 @@ end
 
 ### Debugging
 
-Run your worker with `RESQUE_DEBUG=true` to see payloads printed before they are used to determine uniqueness, as well as a lot of other debugging output.
+Run your worker with `RESQUE_DEBUG=true` to see payloads printed before they are
+ used to determine uniqueness, as well as a lot of other debugging output.
 
 ### Customize Unique Keys Per Job
 

data/lib/resque-unique_by_arity.rb

@@ -0,0 +1,17 @@
+require 'resque/unique_by_arity/version'
+
+# External Gems
+require 'colorized_string'
+require 'resque'
+
+# External Resque Plugins
+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'

data/lib/resque/plugins/unique_by_arity.rb

@@ -35,17 +35,48 @@ module Resque
         # As a result we can configure per class.
         @configuration.base_klass_name = base.to_s
         @configuration.validate
-        base.send(:extend, Resque::UniqueByArity)
+        base.send(:extend, Resque::UniqueByArity::UniqueJob)
         base.uniqueness_config_reset(@configuration.dup)
 
-        # gem is unique_in_queue, which is a rewrite of resque-loner
-        # see: https://github.com/neighborland/resque_solo
+        # gem is resque-unique_in_queue, which is a rewrite of resque-solo / resque-loner
+        # see: https://github.com/pboling/resque-unique_in_queue
         # defines a redis_key method, which we have to override.
         base.send(:include, Resque::Plugins::UniqueInQueue) if @configuration.unique_in_queue || @configuration.unique_across_queues
 
         # gem is resque-unique_at_runtime, which is a rewrite of resque-lonely_job
         # see: https://github.com/pboling/resque-unique_at_runtime
-        base.send(:extend, Resque::Plugins::UniqueAtRuntime) if @configuration.unique_at_runtime
+        base.send(:include, Resque::Plugins::UniqueAtRuntime) if @configuration.unique_at_runtime
+
+        # For resque-unique_at_runtime
+        #
+        if @configuration.runtime_lock_timeout
+          base.instance_variable_set(:@runtime_lock_timeout, @configuration.runtime_lock_timeout)
+        end
+
+        if @configuration.runtime_requeue_interval
+          base.instance_variable_set(:@runtime_requeue_interval, @configuration.runtime_requeue_interval)
+        end
+
+        if @configuration.unique_at_runtime_key_base
+          base.instance_variable_set(:@unique_at_runtime_key_base, @configuration.unique_at_runtime_key_base)
+        end
+
+        # For resque-unique_in_queue
+        #
+        if @configuration.lock_after_execution_period
+          base.instance_variable_set(:@lock_after_execution_period, @configuration.lock_after_execution_period)
+        end
+
+        if @configuration.ttl
+          base.instance_variable_set(:@ttl, @configuration.ttl)
+        end
+
+        # Normally doesn't make sense to override per each class because
+        #   it wouldn't be able to determine or enforce uniqueness across queues,
+        #   and general cleanup of stray keys would be nearly impossible.
+        if @configuration.unique_in_queue_key_base
+          base.instance_variable_set(:@unique_in_queue_key_base, @configuration.unique_in_queue_key_base)
+        end
 
         uniqueness_cop_module = Resque::UniqueByArity::Modulizer.to_mod(@configuration)
         # This will override methods from both plugins above, if configured for both

data/lib/resque/unique_by_arity.rb

@@ -1,132 +1,34 @@
-require 'resque/unique_by_arity/version'
+# Just in case some code still does require 'resque/unique_by_arity'
+require 'resque-unique_by_arity'
 
-# External Gems
-require 'colorized_string'
-require 'resque'
-
-# External Resque Plugins
-require 'resque-unique_in_queue'
-require 'resque-unique_at_runtime'
-
-require 'resque/plugins/unique_by_arity'
-require 'resque/unique_by_arity/configuration'
-require 'resque/unique_by_arity/modulizer'
-require 'resque/unique_by_arity/validation'
-
-# Usage:
-#
-# class MyJob
-#   def self.perform(arg1, arg2)
-#   end
-#   include Resque::Plugins::UniqueByArity.new(
-#     arity_for_uniqueness: 1,
-#     arity_validation: :warning, # or nil, false, or :error
-#     unique_at_runtime: true,
-#     unique_in_queue: true
-#   )
-# end
-#
-# NOTE: DO NOT include this module directly.
-#       Use the Resque::Plugins::UniqueByArity approach as above.
-#       This module is ultimately extended into the job class.
 module Resque
   module UniqueByArity
     PLUGIN_TAG = (ColorizedString['[R-UBA] '].green).freeze
 
-    def unique_log(message, config_proxy = nil)
-      config_proxy ||= uniqueness_configuration
-      config_proxy.unique_logger&.send(config_proxy.unique_log_level, message) if config_proxy.unique_logger
-    end
-
-    def unique_debug(message, config_proxy = nil)
-      config_proxy ||= uniqueness_configuration
-      config_proxy.unique_logger&.debug("#{Resque::UniqueByArity::PLUGIN_TAG}#{message}") if config_proxy.debug_mode
+    def log(message, config_proxy = nil)
+      config_proxy ||= configuration
+      config_proxy.logger&.send(config_proxy.log_level, message) if config_proxy.logger
     end
-    module_function(:unique_log, :unique_debug)
+    module_function(:log)
 
-    # There are times when the class will need access to the configuration object,
-    #   such as to override it per instance method
-    def uniq_config
-      @uniqueness_configuration
+    def debug(message, config_proxy = nil)
+      config_proxy ||= configuration
+      config_proxy.logger&.debug("#{Resque::UniqueByArity::PLUGIN_TAG}#{message}") if config_proxy.debug_mode
     end
+    module_function(:debug)
 
-    # For per-class config with a block
-    def uniqueness_configure
-      @uniqueness_configuration ||= Configuration.new
-      yield(@uniqueness_configuration)
+    # For config with a block
+    def configure
+      yield(@configuration)
     end
 
     #### CONFIG ####
+    # Access globally configured settings:
+    #   >> Resque::UniqueByArity.configuration.logger
+    #   => the Logger instance
     class << self
-      attr_accessor :uniqueness_configuration
-    end
-    def uniqueness_config_reset(config = Configuration.new)
-      @uniqueness_configuration = config
-    end
-
-    def uniqueness_log_level
-      @uniqueness_configuration.log_level
-    end
-
-    def uniqueness_log_level=(log_level)
-      @uniqueness_configuration.log_level = log_level
-    end
-
-    def uniqueness_arity_for_uniqueness
-      @uniqueness_configuration.arity_for_uniqueness
-    end
-
-    def uniqueness_arity_for_uniqueness=(arity_for_uniqueness)
-      @uniqueness_configuration.arity_for_uniqueness = arity_for_uniqueness
-    end
-
-    def uniqueness_arity_validation
-      @uniqueness_configuration.arity_validation
-    end
-
-    def uniqueness_arity_validation=(arity_validation)
-      @uniqueness_configuration.arity_validation = arity_validation
-    end
-
-    def uniqueness_lock_after_execution_period
-      @uniqueness_configuration.lock_after_execution_period
-    end
-
-    def uniqueness_lock_after_execution_period=(lock_after_execution_period)
-      @uniqueness_configuration.lock_after_execution_period = lock_after_execution_period
-    end
-
-    def uniqueness_runtime_lock_timeout
-      @uniqueness_configuration.runtime_lock_timeout
-    end
-
-    def uniqueness_runtime_lock_timeout=(runtime_lock_timeout)
-      @uniqueness_configuration.runtime_lock_timeout = runtime_lock_timeout
-    end
-
-    def uniqueness_unique_at_runtime
-      @uniqueness_configuration.unique_at_runtime
-    end
-
-    def uniqueness_unique_at_runtime=(unique_at_runtime)
-      @uniqueness_configuration.unique_at_runtime = unique_at_runtime
-    end
-
-    def uniqueness_unique_in_queue
-      @uniqueness_configuration.unique_in_queue
-    end
-
-    def uniqueness_unique_in_queue=(unique_in_queue)
-      @uniqueness_configuration.unique_in_queue = unique_in_queue
-    end
-
-    def uniqueness_unique_across_queues
-      @uniqueness_configuration.unique_across_queues
-    end
-
-    def uniqueness_unique_across_queues=(unique_across_queues)
-      @uniqueness_configuration.unique_across_queues = unique_across_queues
+      attr_accessor :configuration
     end
-    self.uniqueness_configuration = Configuration.new # setup defaults
+    self.configuration = GlobalConfiguration.instance # setup defaults
   end
 end

data/lib/resque/unique_by_arity/configuration.rb

@@ -1,11 +1,13 @@
 require 'logger'
 module Resque
   module UniqueByArity
+    # This class is for configurations that are per job class, *not* app-wide.
+    # Each setting will default to the global config values.
     class Configuration
       VALID_ARITY_VALIDATION_LEVELS = [:warning, :error, :skip, nil, false].freeze
       SKIPPED_ARITY_VALIDATION_LEVELS = [:skip, nil, false].freeze
-      DEFAULT_AT_RUNTIME_KEY_BASE = 'r-uar'.freeze
-      DEFAULT_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
+      DEFAULT_LOG_LEVEL = :debug
+
       attr_accessor :logger
       attr_accessor :log_level
       attr_accessor :arity_for_uniqueness
@@ -18,27 +20,35 @@ module Resque
       attr_accessor :unique_in_queue
       attr_accessor :unique_in_queue_key_base
       attr_accessor :unique_across_queues
+      attr_accessor :ttl
       attr_accessor :base_klass_name
       attr_accessor :debug_mode
+
       def initialize(**options)
-        @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
-        @log_level = options.key?(:log_level) ? options[:log_level] : :debug
-        @arity_for_uniqueness = options.key?(:arity_for_uniqueness) ? options[:arity_for_uniqueness] : 1
-        @arity_validation = options.key?(:arity_validation) ? options[:arity_validation] : :warning
+        @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_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)
 
-        @lock_after_execution_period = options.key?(:lock_after_execution_period) ? options[:lock_after_execution_period] : nil
-        @runtime_lock_timeout = options.key?(:runtime_lock_timeout) ? options[:runtime_lock_timeout] : nil
-        @runtime_requeue_interval = options.key?(:runtime_requeue_interval) ? options[:runtime_requeue_interval] : nil
-        @unique_at_runtime = options.key?(:unique_at_runtime) ? options[:unique_at_runtime] : false
-        @unique_at_runtime_key_base = options.key?(:unique_at_runtime_key_base) ? options[:unique_at_runtime_key_base] : DEFAULT_AT_RUNTIME_KEY_BASE
-        @unique_in_queue_key_base = options.key?(:unique_in_queue_key_base) ? options[:unique_in_queue_key_base] : DEFAULT_IN_QUEUE_KEY_BASE
-        @unique_in_queue = options.key?(:unique_in_queue) ? options[:unique_in_queue] : false
-        @unique_across_queues = options.key?(:unique_across_queues) ? options[:unique_across_queues] : false
-        # Can't be both unique in queue and unique across queues.
+        @ttl = options.key?(:ttl) ? options[:ttl] : defcon(:ttl) || nil
+        @lock_after_execution_period = options.key?(:lock_after_execution_period) ? options[:lock_after_execution_period] : defcon(:lock_after_execution_period) || nil
+        @runtime_lock_timeout = options.key?(:runtime_lock_timeout) ? options[:runtime_lock_timeout] : defcon(:runtime_lock_timeout) || nil
+        @runtime_requeue_interval = options.key?(:runtime_requeue_interval) ? options[:runtime_requeue_interval] : defcon(:runtime_requeue_interval) || nil
+        @unique_at_runtime = options.key?(:unique_at_runtime) ? options[:unique_at_runtime] : defcon(:unique_at_runtime) || false
+        @unique_at_runtime_key_base = options.key?(:unique_at_runtime_key_base) ? options[:unique_at_runtime_key_base] : defcon(:unique_at_runtime_key_base) || nil
+        @unique_in_queue_key_base = options.key?(:unique_in_queue_key_base) ? options[:unique_in_queue_key_base] : defcon(:unique_in_queue_key_base) || nil
+        @unique_in_queue = options.key?(:unique_in_queue) ? options[:unique_in_queue] : defcon(:unique_in_queue) || false
+        @unique_across_queues = options.key?(:unique_across_queues) ? options[:unique_across_queues] : defcon(:unique_across_queues) || false
+        # Can't be both unique in queue and unique across queues, since they
+        #   must necessarily use different locking key structures, and therefore
+        #   can't both be active.
         raise ArgumentError, "Resque::Plugins::UniqueByArity.new requires either one or none of @unique_across_queues and @unique_in_queue to be true. Having both set to true is non-sensical." if @unique_in_queue && @unique_across_queues
-        env_debug = ENV['RESQUE_DEBUG']
-        @debug_mode = !!(options.key?(:debug_mode) ? options[:debug_mode] : env_debug == 'true' || (env_debug.is_a?(String) && env_debug.match?(/arity/)))
+        @debug_mode = !!(options.key?(:debug_mode) ? options[:debug_mode] : defcon(:debug_mode))
+        if @debug_mode
+          # Make sure there is a logger when in debug_mode
+          @logger ||= Logger.new(STDOUT)
+        end
       end
 
       def validate
@@ -52,16 +62,8 @@ module Resque
         end
       end
 
-      def unique_logger
-        logger
-      end
-
-      def unique_log_level
-        log_level
-      end
-
       def log(msg)
-        Resque::UniqueByArity.unique_log(msg, self)
+        Resque::UniqueByArity.log(msg, self)
       end
 
       def to_hash
@@ -74,6 +76,7 @@ module Resque
           debug_mode: debug_mode,
           lock_after_execution_period: lock_after_execution_period,
           runtime_lock_timeout: runtime_lock_timeout,
+          ttl: ttl,
           unique_at_runtime: unique_at_runtime,
           unique_in_queue: unique_in_queue,
           unique_across_queues: unique_across_queues
@@ -121,6 +124,21 @@ module Resque
           end
         end
       end
+
+      def defcon(sym)
+        Resque::UniqueByArity.configuration.send(sym)
+      end
+
+      def debug_mode=(val)
+        @debug_mode = !!val
+      end
+
+      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/)))
+      end
     end
   end
 end

data/lib/resque/unique_by_arity/global_configuration.rb

@@ -0,0 +1,52 @@
+require 'logger'
+module Resque
+  module UniqueByArity
+    # This class is for configurations that are app-wide, *not per job class.
+    # For this reason it is a Singleton.
+    # Will be used as the default settings for the per-job configs.
+    class GlobalConfiguration < Configuration
+      DEFAULT_LOG_LEVEL = :debug
+      DEFAULT_AT_RUNTIME_KEY_BASE = 'r-uar'.freeze
+      DEFAULT_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
+
+      # For resque-unique_at_runtime
+      DEFAULT_LOCK_TIMEOUT = 60 * 60 * 24 * 5
+      DEFAULT_REQUEUE_INTERVAL = 1
+      DEFAULT_UNIQUE_AT_RUNTIME_KEY_BASE = 'r-uar'.freeze
+
+      # For resque-unique_in_queue
+      DEFAULT_LOCK_AFTER_EXECUTION_PERIOD = 0
+      DEFAULT_TTL = -1
+      DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
+
+      include Singleton
+
+      def initialize
+        debug_mode_from_env
+        @logger = nil
+        @log_level = DEFAULT_LOG_LEVEL
+        @arity_for_uniqueness = nil
+        @arity_validation = nil
+        @lock_after_execution_period = DEFAULT_LOCK_AFTER_EXECUTION_PERIOD
+        @runtime_lock_timeout = DEFAULT_LOCK_TIMEOUT
+        @runtime_requeue_interval = DEFAULT_REQUEUE_INTERVAL
+        @unique_at_runtime_key_base = DEFAULT_AT_RUNTIME_KEY_BASE
+        @unique_in_queue_key_base = DEFAULT_IN_QUEUE_KEY_BASE
+        @unique_at_runtime = false
+        @unique_at_runtime_key_base = DEFAULT_UNIQUE_AT_RUNTIME_KEY_BASE
+        @unique_in_queue_key_base = DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE
+        @unique_in_queue = false
+        @unique_across_queues = false
+        @ttl = DEFAULT_TTL
+        if @debug_mode
+          # Make sure there is a logger when in debug_mode
+          @logger ||= Logger.new(STDOUT)
+        end
+      end
+
+      def defcon(sym)
+        self.send(sym)
+      end
+    end
+  end
+end

data/lib/resque/unique_by_arity/modulizer.rb

@@ -7,7 +7,7 @@ module Resque
             # @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|
               payload = Resque.decode(Resque.encode(payload))
-              Resque::UniqueByArity.unique_debug("payload is #{payload.inspect}")
+              Resque::UniqueByArity.debug("payload is #{payload.inspect}")
               job  = payload['class']
               # It seems possible that some jobs may not have an "args" key in the payload.
               args = payload['args'] || []
@@ -28,36 +28,13 @@ module Resque
             end
           end
 
-          if configuration.lock_after_execution_period
-            instance_variable_set(:@lock_after_execution_period, configuration.lock_after_execution_period)
-          end
-
-          if configuration.runtime_lock_timeout
-            instance_variable_set(:@runtime_lock_timeout, configuration.runtime_lock_timeout)
-          end
-
-          if configuration.runtime_requeue_interval
-            instance_variable_set(:@runtime_requeue_interval, configuration.runtime_requeue_interval)
-          end
-
-          if configuration.unique_at_runtime_key_base
-            instance_variable_set(:@unique_at_runtime_key_base, configuration.unique_at_runtime_key_base)
-          end
-
-          if configuration.unique_in_queue_key_base
-            # Can't be overridden per each class because it wouldn't make sense.
-            # It wouldn't be able to determine or enforce uniqueness across queues,
-            #   and general cleanup of stray keys would be nearly impossible.
-            Resque::UniqueInQueue.uniq_config&.unique_in_queue_key_base = configuration.unique_in_queue_key_base
-          end
-
           if configuration.unique_in_queue || configuration.unique_across_queues
-            ### Gem: unique_in_queue
+            ### Gem: resque-unique_in_queue
             ### Plugin Name: Resque::Plugins::UniqueJob
             ### Provides: Queue-time uniqueness for a single queue, or across queues
             #
             # Returns a string, used by Resque::Plugins::UniqueJob, that will be used as the prefix to the redis key
-            define_method(:unique_at_runtime_redis_key_prefix) do
+            define_method(:unique_in_queue_redis_key_prefix) do
               "unique_job:#{self}"
             end
             #
@@ -69,28 +46,29 @@ module Resque
             # @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)
-              key = "#{unique_at_runtime_key_namespace(queue)}:#{unique_at_runtime_redis_key_prefix}:#{unique_hash}"
-              Resque::UniqueByArity.unique_debug("#{self}.unique_in_queue_redis_key for #{args_for_uniqueness} is: #{ColorizedString[key].green}")
+              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}")
               key
             end
             #
             # @return [Fixnum] number of keys that were deleted
             define_method(:purge_unique_queued_redis_keys) do
               # unique_at_runtime_key_namespace may or may not ignore the queue passed in, depending on config.
-              key_match = "#{unique_at_runtime_key_namespace(instance_variable_get(:@queue))}:#{unique_at_runtime_redis_key_prefix}:*"
+              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.unique_log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueInQueue::PLUGIN_TAG} Purging #{keys.length} keys from #{ColorizedString[key_match].red}")
+              Resque::UniqueByArity.log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueInQueue::PLUGIN_TAG} #{ColorizedString['Purging'].red} #{keys.length} keys from #{ColorizedString[key_match].red}")
               Resque.redis.del keys unless keys.empty?
             end
+
             if configuration.unique_in_queue
               # @return [String] the Redis namespace of the key used to enforce uniqueness (at queue-time)
-              define_method(:unique_at_runtime_key_namespace) do |queue = nil|
-                "#{configuration.unique_in_queue_key_base}:queue:#{queue}:job"
+              define_method(:unique_in_queue_key_namespace) do |queue = nil|
+                "#{unique_in_queue_key_base}:queue:#{queue}:job"
               end
             elsif configuration.unique_across_queues
               # @return [String] the Redis namespace of the key used to enforce uniqueness (at queue-time)
-              define_method(:unique_at_runtime_key_namespace) do |_queue = nil|
-                "#{configuration.unique_in_queue_key_base}:across_queues:job"
+              define_method(:unique_in_queue_key_namespace) do |_queue = nil|
+                "#{unique_in_queue_key_base}:across_queues:job"
               end
             end
           end
@@ -101,27 +79,26 @@ module Resque
           if configuration.unique_at_runtime
             # @return [String] the Redis namespace of the key used to enforce uniqueness (at runtime)
             define_method(:runtime_key_namespace) do
-              "#{configuration.unique_at_runtime_key_base}:#{self}"
+              "#{unique_at_runtime_key_base}:#{self}"
             end
             # Returns a string, used by Resque::Plugins::UniqueAtRuntime, that will be used as the redis key
-            # The versions of redis_key from unique_in_queue and resque-lonely_job are incompatible.
-            # So we forked resque-lonely_job, change the name of the method so it would not conflict,
-            #   and now we can override it, and fix the params to be compatible with the redis_key
-            #   from unique_in_queue
-            # Does not need any customization for arity, because it funnels down to redis_key,
-            #   and we handle the arity option there
+            # The versions of redis_key from resque-solo and resque-lonely_job are incompatible.
+            # So I forked and namespaced the methods according to the gem handling the key.
+            #   Now I can override it, and fix the params to be compatible.
+            # Does not need any customization for arity, because ultimately it
+            #   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)
               key = "#{runtime_key_namespace}:#{unique_hash}"
-              Resque::UniqueByArity.unique_debug("#{ColorizedString['[R-UAR]'].yellow} #{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: #{ColorizedString[key].yellow}")
               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.unique_log("#{ColorizedString['[R-UBA][R-UAR]'].red} Purging #{keys.length} keys from #{ColorizedString[key_match].red}")
+              Resque::UniqueByArity.log("#{Resque::UniqueByArity::PLUGIN_TAG}#{Resque::UniqueAtRuntime::PLUGIN_TAG} #{ColorizedString['Purging'].red} #{keys.length} keys from #{ColorizedString[key_match].red}")
               Resque.redis.del keys unless keys.empty?
             end
           end

data/lib/resque/unique_by_arity/unique_job.rb

@@ -0,0 +1,53 @@
+# Usage:
+#
+# class MyJob
+#   def self.perform(arg1, arg2)
+#   end
+#   include Resque::Plugins::UniqueByArity.new(
+#     arity_for_uniqueness: 1,
+#     arity_validation: :warning, # or nil, false, or :error
+#     unique_at_runtime: true,
+#     unique_in_queue: true
+#   )
+# end
+#
+# NOTE: DO NOT include this module directly.
+#       Use the Resque::Plugins::UniqueByArity approach as above.
+#       This module is ultimately extended into the job class.
+module Resque
+  module UniqueByArity
+    module UniqueJob
+      PLUGIN_TAG = (ColorizedString['[R-UBA] '].green).freeze
+
+      def uniq_log(message, config_proxy = nil)
+        config_proxy ||= uniq_config
+        config_proxy.logger&.send(config_proxy.log_level, message) if config_proxy.logger
+      end
+
+      def uniq_debug(message, config_proxy = nil)
+        config_proxy ||= uniq_config
+        config_proxy.logger&.debug("#{Resque::UniqueByArity::PLUGIN_TAG}#{message}") if config_proxy.debug_mode
+      end
+
+      # For per-class config with a block
+      def uniqueness_configure
+        @uniqueness_configuration ||= Configuration.new
+        yield(@uniqueness_configuration)
+      end
+
+      #### CONFIG ####
+      class << self
+        attr_accessor :uniqueness_configuration
+      end
+      self.uniqueness_configuration = Configuration.new # setup defaults
+
+      def uniqueness_config_reset(config = Configuration.new)
+        @uniqueness_configuration = config
+      end
+
+      def uniq_config
+        @uniqueness_configuration
+      end
+    end
+  end
+end

data/lib/resque/unique_by_arity/version.rb

@@ -1,5 +1,5 @@
 module Resque
   module UniqueByArity
-    VERSION = '2.0.2'.freeze
+    VERSION = '3.0.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-unique_by_arity
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Peter H. Boling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-10 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -216,7 +216,6 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
-- ".rspec_status"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".ruby-version"
@@ -227,10 +226,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/resque-unique_by_arity.rb
 - lib/resque/plugins/unique_by_arity.rb
 - lib/resque/unique_by_arity.rb
 - lib/resque/unique_by_arity/configuration.rb
+- lib/resque/unique_by_arity/global_configuration.rb
 - lib/resque/unique_by_arity/modulizer.rb
+- lib/resque/unique_by_arity/unique_job.rb
 - lib/resque/unique_by_arity/validation.rb
 - lib/resque/unique_by_arity/version.rb
 - resque-unique_by_arity.gemspec

data/.rspec_status

@@ -1,55 +0,0 @@
-example_id                                                        | status | run_time        |
------------------------------------------------------------------ | ------ | --------------- |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:1]      | passed | 0.00313 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:2:1]    | passed | 0.00099 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:3:1]    | passed | 0.00038 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:4:1]    | passed | 0.00016 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:5:1]    | passed | 0.00017 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:6:1]    | passed | 0.00018 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:7:1]    | passed | 0.0002 seconds  |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:8:1]    | passed | 0.00016 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:9:1]    | passed | 0.00014 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:10:1]   | passed | 0.00014 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:11:1]   | passed | 0.00017 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:12:1]   | passed | 0.00015 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:13:1]   | passed | 0.00017 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:14:1]   | passed | 0.00096 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:14:2:1] | passed | 0.00014 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:1:14:3:1] | passed | 0.00013 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:2:1]      | passed | 0.01014 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:3:1]      | passed | 0.00031 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:3:2]      | passed | 0.00024 seconds |
-./spec/resque/unique_by_arity/configuration_spec.rb[1:1:4:1]      | passed | 0.00017 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:1]                        | passed | 0.00006 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:2:1:1]                    | passed | 0.00094 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:3:1]                      | passed | 0.00062 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:4:1:1]                    | passed | 0.00022 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:5:1:1]                    | passed | 0.00086 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:5:2:1]                    | passed | 0.00026 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:5:3:1]                    | passed | 0.00027 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:6:1]                      | passed | 0.00047 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:7:1]                      | passed | 0.00021 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:7:2:1]                    | passed | 0.00057 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:7:3:1]                    | passed | 0.00062 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:7:4:1]                    | passed | 0.00021 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:1:1:1:1]                | passed | 0.00028 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:1:2:1:1]                | passed | 0.00025 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:1:3:1:1]                | passed | 0.00061 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:2:1:1:1]                | passed | 0.00022 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:2:2:1:1]                | passed | 0.00029 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:2:3:1:1]                | passed | 0.00057 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:3:1:1:1]                | passed | 0.00076 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:3:2:1:1]                | passed | 0.00075 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:3:3:1:1]                | passed | 0.00062 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:4:1:1:1]                | passed | 0.0004 seconds  |
-./spec/resque/unique_by_arity_spec.rb[1:8:4:2:1:1]                | passed | 0.00032 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:4:3:1:1]                | passed | 0.00042 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:5:1:1:1]                | passed | 0.00023 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:5:2:1:1]                | passed | 0.00029 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:8:5:3:1]                  | passed | 0.0002 seconds  |
-./spec/resque/unique_by_arity_spec.rb[1:9:1]                      | passed | 0.0025 seconds  |
-./spec/resque/unique_by_arity_spec.rb[1:10:1:1]                   | passed | 0.00012 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:11:1:1]                   | passed | 0.00029 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:11:2:1:1]                 | passed | 0.00025 seconds |
-./spec/resque/unique_by_arity_spec.rb[1:11:2:2:1]                 | passed | 0.0006 seconds  |
-./spec/resque/unique_by_arity_spec.rb[1:11:2:3:1]                 | passed | 0.0005 seconds  |