resque-unique_at_runtime 3.0.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a8a2e4eac00952a8cccc8cbc74b2b7f4bdbdf7c594f1a0e62891436c0a0c8f8
-  data.tar.gz: f25b46513a61c07c9c37bf6af101ca4504b4e25534ac7842ea3885b2a5a30a4b
+  metadata.gz: dad974343819e8b331d91885f9b24b1856bc0e02e6adfcdaba9421e8f9eb2165
+  data.tar.gz: a84c76ce456fdf74343384852dc68a8dac2ca30cd66f382a947a0f419adeeceb
 SHA512:
-  metadata.gz: aa08c400e7ad45f3265ad39dd01fb0cdcdd9ea8891bbbf88671972d4625c289cf15d01e7609d56b06a7dafbac0687f19acdf3ceeb54106438cdde231823bdf77
-  data.tar.gz: 5eee11d58a60feb72ff8585286f19954d6c1c779d1a33288f4d52a5bd54ad08e961226af72c7a559811269c6de1c918c83f505cd6c492caa6bdec0a29b10f70b
+  metadata.gz: 6508204325cc2a97856c691bf98ddb9e91ebaab082d9e36fc21e347f2ed409b4ed3ef9fae851394441158dd03fd9e3d99e35403b4594787e01dbe6348ac0dd4f
+  data.tar.gz: 122f39d393b7f8fd5cc44d71024a78e4501af60dc289aaea7cd18c4fa5698534a1a50f4aa19d06f10685030bc770bef5bb4aab003eaae7cddcdccd59b3b697c6

data/README.md

@@ -58,6 +58,25 @@ Or install it yourself as:
 
 ## Usage
 
+`resque-unique_at_runtime` utilizes 3 class instance variables that can be set
+in your Jobs, in addition to the standard `@queue`.  Here they are, with their
+default values:
+
+```ruby
+@runtime_lock_timeout = 60 * 60 * 24 * 5
+@runtime_requeue_interval = 1
+@unique_at_runtime_key_base = 'r-uar'.freeze
+```
+
+The last one, in normal circumstances, shouldn't be set as different per class,
+or uniqueness cleanup becomes more difficult.
+
+It should be set only once, globally:
+
+```ruby
+Resque::UniqueAtRuntime.configuration.unique_at_runtime_key_base = 'my-custom'
+```
+
 #### Example #1 -- One job running per queue
 
     require 'resque-unique_at_runtime'

data/lib/resque-unique_at_runtime.rb

@@ -23,62 +23,27 @@ module Resque
   module UniqueAtRuntime
     PLUGIN_TAG = (ColorizedString['[R-UAR] '].blue).freeze
 
-    def runtime_unique_log(message, config_proxy = nil)
-      config_proxy ||= uniqueness_configuration
-      config_proxy.unique_logger&.send(config_proxy.unique_log_level, message)
+    def log(message)
+      configuration.logger&.send(configuration.log_level, message) if configuration.logger
     end
 
-    def runtime_unique_debug(message, config_proxy = nil)
-      config_proxy ||= uniqueness_configuration
-      config_proxy.unique_logger&.debug("#{PLUGIN_TAG}#{message}") if config_proxy.debug_mode
-    end
-
-    # 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)
+      configuration.logger&.debug("#{PLUGIN_TAG}#{message}") if configuration.debug_mode
     end
 
     # For per-class config with a block
-    def uniqueness_configure
-      @uniqueness_configuration ||= Configuration.new
-      yield(@uniqueness_configuration)
+    def configure
+      yield(@configuration)
     end
 
     #### CONFIG ####
     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 unique_at_runtime_key_base
-      Configuration.unique_at_runtime_key_base
-    end
-
-    def unique_at_runtime_key_base=(key_base)
-      Configuration.unique_at_runtime_key_base = key_base
+      attr_accessor :configuration
     end
 
-    self.uniqueness_configuration = Configuration.new # setup defaults
+    self.configuration = Configuration.instance # setup defaults
 
-    module_function(:runtime_unique_log,
-                    :runtime_unique_debug,
-                    :uniq_config,
-                    :uniqueness_configure,
-                    :uniqueness_config_reset,
-                    :uniqueness_log_level,
-                    :uniqueness_log_level=,
-                    :unique_at_runtime_key_base,
-                    :unique_at_runtime_key_base=)
+    module_function(:log,
+                    :debug)
   end
 end

data/lib/resque/plugins/unique_at_runtime.rb

@@ -25,17 +25,24 @@ module Resque
         end
 
         def runtime_lock_timeout
-          instance_variable_get(:@runtime_lock_timeout) || Resque::UniqueAtRuntime.uniq_config&.lock_timeout
+          instance_variable_get(:@runtime_lock_timeout) ||
+              instance_variable_set(:@runtime_lock_timeout, Resque::UniqueAtRuntime.configuration&.lock_timeout)
         end
 
         def runtime_requeue_interval
-          instance_variable_get(:@runtime_requeue_interval) || Resque::UniqueAtRuntime.uniq_config&.requeue_interval
+          instance_variable_get(:@runtime_requeue_interval) ||
+              instance_variable_set(:@runtime_requeue_interval, Resque::UniqueAtRuntime.configuration&.requeue_interval)
+        end
+
+        def unique_at_runtime_key_base
+          instance_variable_get(:@unique_at_runtime_key_base) ||
+              instance_variable_set(:@unique_at_runtime_key_base, Resque::UniqueAtRuntime.configuration&.unique_at_runtime_key_base)
         end
 
         # Overwrite this method to uniquely identify which mutex should be used
         # for a resque worker.
         def unique_at_runtime_redis_key(*_)
-          Resque::UniqueAtRuntime.runtime_unique_debug("getting key for #{@queue}!")
+          Resque::UniqueAtRuntime.debug("getting key for #{@queue}!")
           "#{unique_at_runtime_key_base}:#{@queue}"
         end
 
@@ -50,7 +57,7 @@ module Resque
           key = unique_at_runtime_redis_key(*args)
           timeout = runtime_lock_timeout_at(now)
 
-          Resque::UniqueAtRuntime.runtime_unique_debug("attempting to lock queue with #{key}")
+          Resque::UniqueAtRuntime.debug("attempting to lock queue with #{key}")
 
           # Per http://redis.io/commands/setnx
           return false if Resque.redis.setnx(key, timeout)
@@ -62,7 +69,7 @@ module Resque
 
         def unlock_queue(*args)
           key = unique_at_runtime_redis_key(*args)
-          Resque::UniqueAtRuntime.runtime_unique_debug("unlock queue with #{key}")
+          Resque::UniqueAtRuntime.debug("unlock queue with #{key}")
           Resque.redis.del(key)
         end
 
@@ -72,7 +79,7 @@ module Resque
 
         def before_perform_lock_runtime(*args)
           if (key = queue_locked?(*args))
-            Resque::UniqueAtRuntime.runtime_unique_debug("failed to lock queue with #{key}")
+            Resque::UniqueAtRuntime.debug("failed to lock queue with #{key}")
 
             # Sleep so the CPU's rest
             sleep(runtime_requeue_interval)
@@ -83,7 +90,7 @@ module Resque
             # and don't perform
             raise Resque::Job::DontPerform
           else
-            Resque::UniqueAtRuntime.runtime_unique_debug('check passed will perform')
+            Resque::UniqueAtRuntime.debug('check passed will perform')
             true
           end
         end
@@ -98,13 +105,9 @@ module Resque
         #   duplicates the on_failure unlock, but that's a small price to pay for
         #   uniqueness.
         def on_failure_unlock_runtime(*args)
-          Resque::UniqueAtRuntime.runtime_unique_debug('on failure unlock')
+          Resque::UniqueAtRuntime.debug('on failure unlock')
           unlock_queue(*args)
         end
-
-        def unique_at_runtime_key_base
-          instance_variable_get(:@unique_at_runtime_key_base) || Resque::UniqueAtRuntime.uniq_config&.unique_at_runtime_key_base
-        end
       end
     end
   end

data/lib/resque/unique_at_runtime/configuration.rb

@@ -4,58 +4,54 @@ require 'logger'
 module Resque
   module UniqueAtRuntime
     class Configuration
-      DEFAULT_AT_RUNTIME_KEY_BASE = 'r-uae'
       DEFAULT_LOCK_TIMEOUT = 60 * 60 * 24 * 5
       DEFAULT_REQUEUE_INTERVAL = 1
+      DEFAULT_UNIQUE_AT_RUNTIME_KEY_BASE = 'r-uar'.freeze
+      DEFAULT_LOG_LEVEL = :debug
 
-      attr_accessor :logger,
-                    :log_level,
+      include Singleton
+
+      attr_accessor :debug_mode,
                     :lock_timeout,
+                    :log_level,
+                    :logger,
                     :requeue_interval,
-                    :debug_mode
-
-      class << self
-        attr_accessor :unique_at_runtime_key_base
-      end
-      # Normally isn't set per job, so it will match across all runtime jobs.
-      @unique_at_runtime_key_base = DEFAULT_AT_RUNTIME_KEY_BASE
-
-      def initialize(**options)
-        @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
-        @log_level = options.key?(:log_level) ? options[:log_level] : :debug
-        @unique_at_runtime_key_base = options.key?(:unique_at_runtime_key_base) ? options[:unique_at_runtime_key_base] : nil
-        @lock_timeout = options.key?(:lock_timeout) ? options[:lock_timeout] : DEFAULT_LOCK_TIMEOUT
-        @requeue_interval = options.key?(:requeue_interval) ? options[:requeue_interval] : DEFAULT_REQUEUE_INTERVAL
-        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?(/runtime/)))
-      end
-
-      def unique_logger
-        logger
-      end
-
-      def unique_log_level
-        log_level
-      end
-
-      def log(msg)
-        Resque::UniqueAtRuntime.runtime_unique_log(msg, self)
-      end
-
-      def unique_at_runtime_key_base
-        @unique_at_runtime_key_base || self.class.unique_at_runtime_key_base
+                    :unique_at_runtime_key_base
+
+      def initialize
+        debug_mode_from_env
+        @lock_timeout = DEFAULT_LOCK_TIMEOUT
+        @log_level = DEFAULT_LOG_LEVEL
+        @logger = nil
+        @requeue_interval = DEFAULT_REQUEUE_INTERVAL
+        @unique_at_runtime_key_base = DEFAULT_UNIQUE_AT_RUNTIME_KEY_BASE
+        if @debug_mode
+          # Make sure there is a logger when in debug_mode
+          @logger ||= Logger.new(STDOUT)
+        end
       end
 
       def to_hash
         {
-          logger: logger,
-          log_level: log_level,
           debug_mode: debug_mode,
-          unique_at_runtime_key_base: unique_at_runtime_key_base,
           lock_timeout: lock_timeout,
-          requeue_interval: requeue_interval
+          log_level: log_level,
+          logger: logger,
+          requeue_interval: requeue_interval,
+          unique_at_runtime_key_base: unique_at_runtime_key_base
         }
       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?(/runtime/)))
+      end
     end
   end
 end

data/lib/resque/unique_at_runtime/version.rb

@@ -2,6 +2,6 @@
 
 module Resque
   module UniqueAtRuntime
-    VERSION = '3.0.2'
+    VERSION = '4.0.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-unique_at_runtime
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 4.0.0
 platform: ruby
 authors:
 - Peter H. Boling
@@ -9,7 +9,7 @@ authors:
 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