sidekiq-max-jobs 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bf624b8b84bbfd78039b22826e440c7218c9850207a55a1a24bfc046a0812a4
-  data.tar.gz: 364ca8c57ac52151636f7c9a0feb7ffe18d758fd95772fb692b0802fb634bef6
+  metadata.gz: 9e52017db21742cf50ed432d2773add32e29a8119341a1d9dc757b9817a3aee9
+  data.tar.gz: 3c5609487bb19a7de4c24cbf389e5faf6a54819a61c7fef368562c74bbc22f02
 SHA512:
-  metadata.gz: 12548204b50a4f9d3dfec6470d3488b03fc672c7c41c12e6554ed350004ce63b42d322043c21dfc023fbd6fc819a724c5a167d62494a0615be0c8d4e71bfda19
-  data.tar.gz: 7e704fde12c9f64b200ac001f6824821ec6e0698235d4493e01a30ff49f27e3742373ae38f0ef91c013b5ee08986bf619cb6c2922eff44c79b3898444b4c3984
+  metadata.gz: 78b270607d7c393cd62fb73e111332197177310856b43a7ec4496ae69beb08ead4edd8ccdf15ecbb99fa8fe3892bb2a150aac315ee657cbe9070b29058a3ba2c
+  data.tar.gz: fb7cb69631840c6082d91333a6b387e1abd2a1173ab71948908b11e0b4a064b7c8a4915bdd2893495581b52b89d351b82ab2146b665e4f21ac5db38aa04dc132

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2020-06-17 22:45:10 -0500 using RuboCop version 0.85.1.
+# on 2020-06-21 09:12:56 -0500 using RuboCop version 0.85.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -14,7 +14,7 @@ Lint/RescueException:
 # Offense count: 1
 # Configuration parameters: IgnoredMethods.
 Metrics/AbcSize:
-  Max: 27
+  Max: 31
 
 # Offense count: 1
 # Configuration parameters: CountComments, ExcludedMethods.
@@ -25,17 +25,22 @@ Metrics/BlockLength:
 # Offense count: 1
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 152
+  Max: 193
 
 # Offense count: 1
 # Configuration parameters: IgnoredMethods.
 Metrics/CyclomaticComplexity:
-  Max: 7
+  Max: 10
 
 # Offense count: 1
 # Configuration parameters: CountComments, ExcludedMethods.
 Metrics/MethodLength:
-  Max: 24
+  Max: 28
+
+# Offense count: 1
+# Configuration parameters: IgnoredMethods.
+Metrics/PerceivedComplexity:
+  Max: 10
 
 # Offense count: 1
 # Cop supports --auto-correct.

data/README.md

@@ -52,7 +52,7 @@ end
 If everything above is successful the next time you start your worker you will
 see a message like the following:
 ```bash
-2020-06-10T00:23:31.789Z pid=73703 tid=oxifk6l13 INFO: Max-Jobs middleware enabled, shutting down pid: 73703 when max-jobs quota is reached
+2020-06-10T00:23:31.789Z pid=73703 tid=oxifk6l13 INFO: Max-Jobs middleware enabled, shutting down pid: 73703 when quota is reached
 ```
 
 Configuration Options
@@ -62,30 +62,36 @@ Above we covered how to get started, but that's only the beginning. There are a
 few configuration options available to you to customize the middleware's
 behavior (currently only configurable via the environment):
 
-* `MAX_JOBS`: The number of jobs to process before terminating (default: `100`)
+* `MAX_JOBS`: The number of jobs to process before terminating (default: `500`)
 * `MAX_JOBS_JITTER`: Used as the upper-bound for calculating a random number
 between 1 and the value specified. This value is added to the `MAX_JOBS` value,
 mentioned above, to decrease the likelihood that all of your `Worker(s)`
-restart at / around the same time (default: `rand(1)`)
+restart at / around the same time (default: `rand(-1)`)
 * `MAX_JOBS_<QUEUE>`: The number of jobs to process for a specific queue before
-terminating (default: `(ENV['MAX_JOBS'] || 100).to_i`)
+terminating (default: `-1`)
 * `MAX_JOBS_JITTER_<QUEUE>`: Used as the upper-bound for calculating a random
 number between 1 and the value specified. This value is added to the
 `MAX_JOBS_<QUEUE>` value, mentioned above, to decreased the likelihood that all
 of your `Worker(s)` restart at / around the same time (default:
-`rand((ENV['MAX_JOBS_JITTER'] || 1).to_i)`)
+`rand(-1)`)
+* `MAX_JOBS_RUNTIME`: The total time in seconds to run before terminating
+(default: `-1`)
+* `MAX_JOBS_RUNTIME_JITTER`: Used as the upper-bound for calculating a random
+number between 1 and the value specified. This value is added to the
+`MAX_JOBS_RUNTIME` value, mentioned above, to decrease the likelihood that all
+of your `Worker(s)` restart at / around the same time (default: `rand(-1)`)
 
 Important Note
 --------------
 
-When determining if the max-job quota has been reached the total jobs processed
-is checked first, followed by the jobs processed for the current queue. If your
-`Worker(s)` are handling multiple queues it is generally recommended that you
-set the total value to the same value as your highest queue value (e.g. if you
-had `MAX_JOBS_FOO=100` and `MAX_JOBS_BAR=200` it probably makes sense to set
-`MAX_JOBS=200`, if not a little bit lower). Setting the right limits ultimately
-depends on the intensity / resource needs of the work being performed. The same
-rule of thumb applies to `MAX_JOBS_JITTER` as well.
+When determining if the max-job quota has been reached the runtime is checked
+first, followed by the total jobs processed, followed by the jobs processed for
+the current queue. If your `Worker(s)` are handling multiple queues it is
+recommended that you set the total value to the same value as your highest queue
+value (e.g. if you had `MAX_JOBS_FOO=100` and `MAX_JOBS_BAR=200` it probably
+makes sense to set `MAX_JOBS=200`, if not a little bit lower). Setting the right
+limits ultimately depends on the intensity / resource needs of the work being
+performed. The same rule of thumb applies to `MAX_JOBS_JITTER` as well.
 
 Contributing
 ------------

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.1.0

data/lib/sidekiq/middleware/server/max_jobs.rb

@@ -4,6 +4,8 @@ module Sidekiq
   module Middleware
     module Server
       class MaxJobs
+        # Version
+
         VERSION = File.read(
           File.join(
             File.dirname(__FILE__),
@@ -16,143 +18,185 @@ module Sidekiq
         ).strip
 
         class << self
+          # Constant(s)
+
+          COUNTER_FOR_QUEUE_KEY_TEMPLATE = 'COUNTER_%s'
+          COUNTER_KEY = 'COUNTER'
+          LOG_INITIALIZATION_TEMPLATE = \
+            'Max-Jobs middleware enabled, shutting down pid: %d when quota is reached'
+          LOG_MAX_JOBS_QUOTA_MET_FOR_QUEUE_TEMPLATE = \
+            'Max-Jobs queue quota met for: "%s", shutting down pid: %d'
+          LOG_MAX_JOBS_QUOTA_MET_TEMPLATE = \
+            'Max-Jobs total quota met, shutting down pid: %d'
+          LOG_MAX_JOBS_RUNTIME_QUOTA_MET_TEMPLATE = \
+            'Max-Jobs runtime quota met, shutting down pid: %d'
+          MAX_JOBS_FOR_QUEUE_KEY_TEMPLATE = 'MAX_JOBS_%s'
+          MAX_JOBS_JITTER_FOR_QUEUE_KEY_TEMPLATE = 'MAX_JOBS_JITTER_%s'
+          MAX_JOBS_JITTER_KEY = 'MAX_JOBS_JITTER'
+          MAX_JOBS_KEY = 'MAX_JOBS'
+          MAX_JOBS_RUNTIME_JITTER_KEY = 'MAX_JOBS_RUNTIME_JITTER'
+          MAX_JOBS_RUNTIME_WITH_JITTER_KEY = 'MAX_JOBS_RUNTIME_WITH_JITTER'
+          MAX_JOBS_RUNTIME_KEY = 'MAX_JOBS_RUNTIME'
+          MAX_JOBS_WITH_JITTER_FOR_QUEUE_KEY_TEMPLATE = \
+            'MAX_JOBS_WITH_JITTER_%s'
+          MAX_JOBS_WITH_JITTER_KEY = 'MAX_JOBS_WITH_JITTER'
+          MUTEX_KEY = 'MUTEX'
+          PID_KEY = 'PID'
+          START_TIME_KEY = 'START_TIME'
+          TERM = 'TERM'
+          TERMINATING_KEY = 'TERMINATING'
+
+          # Default(s)
+
+          DEFAULT_MAX_JOBS = 500
+          DEFAULT_MAX_JOBS_FOR_QUEUE = -1
+          DEFAULT_MAX_JOBS_JITTER = -1
+          DEFAULT_MAX_JOBS_JITTER_FOR_QUEUE = -1
+          DEFAULT_MAX_JOBS_RUNTIME = -1
+          DEFAULT_MAX_JOBS_RUNTIME_JITTER = -1
+
+          # Helper Method(s)
+
           def cache
             @cache ||= {}
           end
 
           def counter
-            key = counter_key
+            key = COUNTER_KEY
             cache[key] ||= 0
           end
 
           def counter_for_queue(queue)
-            key = counter_for_queue_key(queue)
+            key = format(COUNTER_FOR_QUEUE_KEY_TEMPLATE, queue.upcase)
             cache[key] ||= 0
           end
 
-          def counter_for_queue_key(queue)
-            "COUNTER_#{queue.upcase}"
-          end
-
-          def counter_key
-            'COUNTER'
-          end
-
-          def default_max_jobs
-            100
-          end
-
-          def default_max_jobs_jitter
-            1
-          end
-
           def increment_counter!
-            key = counter_key
+            key = COUNTER_KEY
             cache[key] = (cache[key] || 0).next
           end
 
           def increment_counter_for_queue!(queue)
-            key = counter_for_queue_key(queue)
+            key = format(COUNTER_FOR_QUEUE_KEY_TEMPLATE, queue.upcase)
             cache[key] = (cache[key] || 0).next
           end
 
           def log_info(message)
-            ::Sidekiq.logger.info(message) if defined?(::Sidekiq.logger)
+            logger_defined = defined?(::Sidekiq.logger)
+            logger_defined ? ::Sidekiq.logger.info(message) : puts(message)
           end
 
           def log_initialization!
-            log_info("Max-Jobs middleware enabled, shutting down pid: #{pid} when max-jobs quota is reached")
+            message = format(LOG_INITIALIZATION_TEMPLATE, pid)
+            log_info(message)
           end
 
-          def max_jobs
-            key = max_jobs_key
-            cache[key] ||= (ENV[key] || default_max_jobs).to_i
+          def log_max_jobs_quota_met!
+            message = format(LOG_MAX_JOBS_QUOTA_MET_TEMPLATE, pid)
+            log_info(message)
           end
 
-          def max_jobs_for_queue(queue)
-            key = max_jobs_for_queue_key(queue)
-            cache[key] ||= (
-              ENV[key] ||
-              ENV[max_jobs_key] ||
-              default_max_jobs
-            ).to_i
+          def log_max_jobs_quota_met_for_queue!(queue)
+            message = format(
+              LOG_MAX_JOBS_QUOTA_MET_FOR_QUEUE_TEMPLATE,
+              queue,
+              pid
+            )
+            log_info(message)
+          end
+
+          def log_max_jobs_runtime_quota_met!
+            message = format(LOG_MAX_JOBS_RUNTIME_QUOTA_MET_TEMPLATE, pid)
+            log_info(message)
           end
 
-          def max_jobs_for_queue_key(queue)
-            "MAX_JOBS_#{queue.upcase}"
+          def max_jobs
+            key = MAX_JOBS_KEY
+            cache[key] ||= (ENV[key] || DEFAULT_MAX_JOBS).to_i
+          end
+
+          def max_jobs_for_queue(queue)
+            key = format(MAX_JOBS_FOR_QUEUE_KEY_TEMPLATE, queue.upcase)
+            cache[key] ||= (ENV[key] || DEFAULT_MAX_JOBS_FOR_QUEUE).to_i
           end
 
           def max_jobs_jitter
-            key = max_jobs_jitter_key
-            cache[key] ||= rand((ENV[key] || default_max_jobs_jitter).to_i)
+            key = MAX_JOBS_JITTER_KEY
+            cache[key] ||= rand((ENV[key] || DEFAULT_MAX_JOBS_JITTER).to_i)
           end
 
           def max_jobs_jitter_for_queue(queue)
-            key = max_jobs_jitter_for_queue_key(queue)
-            cache[key] ||= rand(
-              (
-                ENV[key] ||
-                ENV[max_jobs_jitter_key] ||
-                default_max_jobs_jitter
-              ).to_i
-            )
+            key = format(MAX_JOBS_JITTER_FOR_QUEUE_KEY_TEMPLATE, queue.upcase)
+            cache[key] ||= \
+              rand((ENV[key] || DEFAULT_MAX_JOBS_JITTER_FOR_QUEUE).to_i)
           end
 
-          def max_jobs_jitter_for_queue_key(queue)
-            "MAX_JOBS_JITTER_#{queue.upcase}"
+          def max_jobs_quota_met?
+            quota = max_jobs_with_jitter
+            quota.positive? ? counter == quota : false
+          end
+
+          def max_jobs_quota_met_for_queue?(queue)
+            quota = max_jobs_with_jitter_for_queue(queue)
+            quota.positive? ? counter_for_queue(queue) == quota : false
+          end
+
+          def max_jobs_runtime
+            key = MAX_JOBS_RUNTIME_KEY
+            cache[key] ||= (ENV[key] || DEFAULT_MAX_JOBS_RUNTIME).to_i
+          end
+
+          def max_jobs_runtime_jitter
+            key = MAX_JOBS_RUNTIME_JITTER_KEY
+            cache[key] ||= \
+              rand((ENV[key] || DEFAULT_MAX_JOBS_RUNTIME_JITTER).to_i)
           end
 
-          def max_jobs_jitter_key
-            'MAX_JOBS_JITTER'
+          def max_jobs_runtime_quota_met?
+            quota = max_jobs_runtime_with_jitter
+            quota.positive? ? (::Time.now.to_i - start_time) >= quota : false
           end
 
-          def max_jobs_key
-            'MAX_JOBS'
+          def max_jobs_runtime_with_jitter
+            key = MAX_JOBS_RUNTIME_WITH_JITTER_KEY
+            cache[key] ||= (max_jobs_runtime + max_jobs_runtime_jitter)
           end
 
           def max_jobs_with_jitter
-            key = max_jobs_with_jitter_key
+            key = MAX_JOBS_WITH_JITTER_KEY
             cache[key] ||= (max_jobs + max_jobs_jitter)
           end
 
           def max_jobs_with_jitter_for_queue(queue)
-            key = max_jobs_with_jitter_for_queue_key(queue)
+            key = \
+              format(MAX_JOBS_WITH_JITTER_FOR_QUEUE_KEY_TEMPLATE, queue.upcase)
             cache[key] ||= \
               (max_jobs_for_queue(queue) + max_jobs_jitter_for_queue(queue))
           end
 
-          def max_jobs_with_jitter_for_queue_key(queue)
-            "MAX_JOBS_WITH_JITTER_#{queue.upcase}"
-          end
-
-          def max_jobs_with_jitter_key
-            'MAX_JOBS_WITH_JITTER'
-          end
-
           def mutex
-            key = mutex_key
+            key = MUTEX_KEY
             cache[key] ||= ::Mutex.new
           end
 
-          def mutex_key
-            'MUTEX'
-          end
-
           def pid
-            key = pid_key
+            key = PID_KEY
             cache[key] ||= ::Process.pid
           end
 
-          def pid_key
-            'PID'
+          def start_time
+            key = START_TIME_KEY
+            cache[key] ||= ::Time.now.to_i
           end
 
-          def quota_met?
-            counter == max_jobs_with_jitter
+          def terminate!
+            key = TERMINATING_KEY
+            cache[key] = true && ::Process.kill(TERM, pid)
           end
 
-          def quota_met_for_queue?(queue)
-            counter_for_queue(queue) == max_jobs_with_jitter_for_queue(queue)
+          def terminating?
+            key = TERMINATING_KEY
+            cache[key] == true
           end
         end
 
@@ -165,36 +209,44 @@ module Sidekiq
           begin
             yield
           rescue Exception
-            # Set the `exception_raised` boolean to `true` so that the
-            # job-counter *is not* incremented in the `ensure` block
+            # Set the `exception_raised` boolean to `true` so that the counter
+            # *is not* incremented in the `ensure` block
             exception_raised = true
             # Re-raise the `Exception` so that _Sidekiq_ can deal w/ it
             raise
           ensure
-            if !exception_raised
+            if !exception_raised && !self.class.terminating?
               self.class.mutex.synchronize do
+                # Controls whether or not the process will be TERMinated at the
+                # end of the block
                 terminate = false
 
+                # First check if the runtime quota has been met
+                if self.class.max_jobs_runtime_quota_met?
+                  self.class.log_max_jobs_runtime_quota_met!
+                  terminate = true
+                end
+
                 # Increment the total counter
                 self.class.increment_counter!
 
-                # First check if the total quota has been met
-                if self.class.quota_met?
-                  self.class.log_info("Max-Jobs quota met, shutting down pid: #{self.class.pid}")
+                # Next, check if the total quota has been met
+                if !terminate && self.class.max_jobs_quota_met?
+                  self.class.log_max_jobs_quota_met!
                   terminate = true
                 end
 
                 # Increment the queue specific counter
                 self.class.increment_counter_for_queue!(queue)
 
-                # Now check if the queue specific quota has been met
-                if !terminate && self.class.quota_met_for_queue?(queue)
-                  self.class.log_info(%(Max-Jobs quota met for queue: "#{queue}", shutting down pid: #{self.class.pid}))
+                # Last[ly], check if the queue quota has been met
+                if !terminate && self.class.max_jobs_quota_met_for_queue?(queue)
+                  self.class.log_max_jobs_quota_met_for_queue!(queue)
                   terminate = true
                 end
 
-                # If applicable, TERMinate the `Process`
-                ::Process.kill('TERM', self.class.pid) if terminate
+                # If applicable, terminate
+                self.class.terminate! if terminate
               end
             end
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-max-jobs
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Jonathan W. Zaleski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-18 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq