activejob-traffic_control 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a536acd2cfc994594b0ae3c7e463b4aac834ba5
-  data.tar.gz: 87ab13103b57fe115c1b287c18714662892a42e9
+  metadata.gz: 2906ae48cd5953f18837860c3685e3ebf8a2dd84
+  data.tar.gz: 5bb69b07b5439da6c1f56d5674fbfec37bd111d8
 SHA512:
-  metadata.gz: fa226f177e0f5cb5408222de47f3652ccf88ee591719a39521db19fbc68ff21fca906e6a8c06e2eba7615f5be7b3ec04561121a539198d5e75a297d8cbd151da
-  data.tar.gz: fe358db32250fbb19b129d7061d2abd3cd5129e86a149a16e9b6c234d05cca72a400d06692d691426bb3927b5384cfd9544db39d570fcf97a1727e22fe08410e
+  metadata.gz: 5887b615c100a481113967f5541c4e4d86621a4ce9a4ae604dcac4c524c53d0a097ec30ce9a5d88d6bd30d18fdcce4646d8731d660a190532fc496a31b19a39a
+  data.tar.gz: d5ccb7e7fa1c4782bcc1650a62d6f1ca17117aace77a130e2c6561714d97619faec95f86b5526516772f3ca429361ce4701e727c212585d8f896528b0de2170c

data/.gitignore

@@ -1,9 +1,18 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rubocop.yml

@@ -1,4 +1,5 @@
 AllCops:
+  TargetRubyVersion: 2.3
   Exclude:
     - .git/**/*
     - tmp/**/*

data/Gemfile

@@ -1,4 +1,6 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in activejob-traffic_control.gemspec
 gemspec

data/README.md

@@ -23,18 +23,15 @@ Or install it yourself as:
 `ActiveJob::TrafficControl` adds three modules you can mixin to your job classes as needed, or to `ApplicationJob` if you are using ActiveJob 5+ (or you have created a base job class yourself).
 
 ```ruby
-ActiveJob::TrafficControl.client = ConnectionPool.new(size: 5, timeout: 5) { Redis.new } # set thresholds as needed
-
-class CanDisableJob < ActiveJob::Base
-  include ActiveJob::TrafficControl::Disable
+# to initialize the type of locking client (memcached vs. redis):
+ActiveJob::TrafficControl.client = ConnectionPool.new(size: 5, timeout: 5) { Redis.new } # set poolthresholds as needed
+# or, ActiveJob::TrafficControl.client = ConnectionPool.new(size: 5, timeout: 5) { Dalli::Client.new }
+# or if not multithreaded, ActiveJob::TrafficControl.client = Redis.new
+```
 
-  def perform
-    # you can pause this job from running by executing `CanDisableJob.disable!` (which will cause the job to be re-enqueued),
-    # or have it be dropped entirely via `CanDisableJob.disable!(drop: true)`
-    # enable it again via `CanDisableJob.enable!`
-  end
-end
+### `Throttle`
 
+```ruby
 class CanThrottleJob < ActiveJob::Base
   include ActiveJob::TrafficControl::Throttle
 
@@ -45,7 +42,11 @@ class CanThrottleJob < ActiveJob::Base
     # if more than that attempt to run, they will be dropped (you can set `drop: false` to have the re-enqueued instead)
   end
 end
+```
 
+### `Concurrency`
+
+```ruby
 class ConcurrencyTestJob < ActiveJob::Base
   include ActiveJob::TrafficControl::Concurrency
 
@@ -54,6 +55,48 @@ class ConcurrencyTestJob < ActiveJob::Base
   def perform
     # only five `ConcurrencyTestJob` will ever run simultaneously
   end
+end
+```
+
+### `Disable`
+
+For `Disable`, you also need to configure the cache client:
+
+```ruby
+ActiveJob::TrafficControl.cache_client = Rails.cache.dalli # if using :dalli_store
+# or ActiveJob::TrafficControl.cache_client = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:11211")
+```
+
+```ruby
+class CanDisableJob < ActiveJob::Base
+  include ActiveJob::TrafficControl::Disable
+
+  def perform
+    # you can pause this job from running by executing `CanDisableJob.disable!` (which will cause the job to be re-enqueued),
+    # or have it be dropped entirely via `CanDisableJob.disable!(drop: true)`
+    # enable it again via `CanDisableJob.enable!`
+  end
+end
+```
+
+### `ApplicationJob`
+
+To provide all of the above functionality to your jobs
+
+```ruby
+class ApplicationJob < ActiveJob::Base
+  include ActiveJob::TrafficControl::Throttle
+  include ActiveJob::TrafficControl::Concurrency
+  include ActiveJob::TrafficControl::Disable
+
+  concurrency 2, drop: false
+  throttle threshold: 10, period: 1.minute, drop: false
+
+  def perform
+    # will have all of the behaviors
+  end
+end
+```
 
 ## Development
 

data/Rakefile

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList['test/**/*_test.rb']
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :default => :test
+task default: :test

data/activejob-traffic_control.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # coding: utf-8
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -9,8 +10,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Nick Elser"]
   spec.email         = ["nick.elser@gmail.com"]
 
-  spec.summary       = %q{Traffic control for ActiveJob}
-  spec.description   = %q{Traffic control for ActiveJob: Concurrency/enabling/throttling}
+  spec.summary       = %q(Traffic control for ActiveJob)
+  spec.description   = %q(Traffic control for ActiveJob: Concurrency/enabling/throttling)
   spec.homepage      = "https://www.activejobtrafficcontrol.com"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

data/lib/active_job/traffic_control.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_job"
 require "active_support/all"
 require "suo"
@@ -34,7 +36,7 @@ module ActiveJob
       def client
         @client ||= begin
           logger.error "defaulting to Redis as the lock client; please set "\
-                       " `ActiveJob::TrafficControl.client` to a Redis or Memcached client,"
+                       " `ActiveJob::TrafficControl.client` to a Redis or Memcached client."
           @client_klass = Suo::Client::Redis
           Redis.new(url: ENV["REDIS_URL"])
         end

data/lib/active_job/traffic_control/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "forwardable"
 
 module ActiveJob
@@ -16,6 +18,22 @@ module ActiveJob
         def cache_client
           ActiveJob::TrafficControl.cache_client
         end
+
+        def lock_key(prefix, job, config_attr)
+          if config_attr
+            if config_attr[:key].respond_to?(:call)
+              "traffic_control:#{prefix}:#{config_attr[:key].call(job)}"
+            else
+              @static_job_key ||= begin
+                if config_attr[:key].present?
+                  "traffic_control:#{prefix}:#{config_attr[:key]}"
+                else
+                  "traffic_control:#{prefix}:#{cleaned_name}"
+                end
+              end
+            end
+          end
+        end
       end
 
       # convenience methods
@@ -26,12 +44,12 @@ module ActiveJob
       def reenqueue(range, reason)
         later_delay = rand(range).seconds
         retry_job(wait: later_delay)
-        logger.error "Re-enqueing #{self.class.name} to run in #{later_delay}s due to #{reason}"
+        logger.info "Re-enqueing #{self.class.name} to run in #{later_delay}s due to #{reason}"
         ActiveSupport::Notifications.instrument "re_enqueue.active_job", job: self, reason: reason
       end
 
       def drop(reason)
-        logger.error "Dropping #{self.class.name} due to #{reason}"
+        logger.info "Dropping #{self.class.name} due to #{reason}"
         ActiveSupport::Notifications.instrument "dropped.active_job", job: self, reason: reason
       end
 

data/lib/active_job/traffic_control/concurrency.rb

@@ -1,27 +1,36 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module TrafficControl
     module Concurrency
       extend ::ActiveSupport::Concern
 
+      CONCURRENCY_REENQUEUE_DELAY = ENV["RACK_ENV"] == "test" ? 1...5 : 30...(60 * 5)
+
       class_methods do
         attr_accessor :job_concurrency
 
         def concurrency(threshold, drop: true, key: nil, wait_timeout: 0.1, stale_timeout: 60 * 10)
           raise ArgumentError, "Concurrent jobs needs to be an integer > 0" if threshold.to_i < 1
-          @job_concurrency = {threshold: threshold.to_i, drop: drop, wait_timeout: wait_timeout.to_f, stale_timeout: stale_timeout.to_f, key: key}
+
+          @job_concurrency = {
+            threshold: threshold.to_i,
+            drop: drop,
+            wait_timeout: wait_timeout.to_f,
+            stale_timeout: stale_timeout.to_f,
+            key: key
+          }
         end
 
-        def concurrency_key
-          if job_concurrency
-            @concurrency_key ||= job_concurrency[:key].present? ? job_concurrency[:key] : "traffic_control:concurrency:#{cleaned_name}".freeze
-          end
+        def concurrency_lock_key(job)
+          lock_key("concurrency", job, job_concurrency)
         end
       end
 
       included do
         include ActiveJob::TrafficControl::Base
 
-        around_perform do |_, block|
+        around_perform do |job, block|
           if self.class.job_concurrency.present?
             lock_options = {
               resources: self.class.job_concurrency[:threshold],
@@ -29,7 +38,7 @@ module ActiveJob
               stale_lock_expiration: self.class.job_concurrency[:stale_timeout]
             }
 
-            with_lock_client(self.class.concurrency_key, lock_options) do |client|
+            with_lock_client(self.class.concurrency_lock_key(job), lock_options) do |client|
               locked = client.lock do
                 block.call
                 true
@@ -37,9 +46,9 @@ module ActiveJob
 
               unless locked
                 if self.class.job_concurrency[:drop]
-                  drop("concurrency".freeze)
+                  drop("concurrency")
                 else
-                  reenqueue(CONCURRENCY_REENQUEUE_DELAY, "concurrency".freeze)
+                  reenqueue(CONCURRENCY_REENQUEUE_DELAY, "concurrency")
                 end
               end
             end

data/lib/active_job/traffic_control/disable.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module TrafficControl
     module Disable
       extend ::ActiveSupport::Concern
 
       DISABLED_REENQUEUE_DELAY = 60...60 * 10
-      SHOULD_DROP = "drop".freeze
-      SHOULD_DISABLE = "true".freeze
+      SHOULD_DROP = "drop"
+      SHOULD_DISABLE = "true"
 
       private_constant :SHOULD_DROP, :SHOULD_DISABLE, :DISABLED_REENQUEUE_DELAY
 
@@ -23,7 +25,7 @@ module ActiveJob
         end
 
         def disable_key
-          @disable_key ||= "traffic_control:disable:#{cleaned_name}".freeze
+          @disable_key ||= "traffic_control:disable:#{cleaned_name}"
         end
       end
 
@@ -35,9 +37,9 @@ module ActiveJob
             disabled = cache_client.read(self.class.disable_key)
 
             if disabled == SHOULD_DROP
-              drop("disabled".freeze)
+              drop("disabled")
             elsif disabled == SHOULD_DISABLE
-              reenqueue(DISABLED_REENQUEUE_DELAY, "disabled".freeze)
+              reenqueue(DISABLED_REENQUEUE_DELAY, "disabled")
             else
               block.call
             end

data/lib/active_job/traffic_control/throttle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module TrafficControl
     module Throttle
@@ -8,36 +10,40 @@ module ActiveJob
 
         def throttle(threshold:, period:, drop: false, key: nil)
           raise ArgumentError, "Threshold needs to be an integer > 0" if threshold.to_i < 1
-          @job_throttling = {threshold: threshold, period: period, drop: drop, key: key}
+
+          @job_throttling = {
+            threshold: threshold,
+            period: period,
+            drop: drop,
+            key: key
+          }
         end
 
-        def throttling_key
-          if job_throttling
-            @throttling_key ||= job_throttling[:key].present? ? job_throttling[:key] : "traffic_control:throttling:#{cleaned_name}".freeze
-          end
+        def throttling_lock_key(job)
+          lock_key("throttle", job, job_throttling)
         end
       end
 
       included do
         include ActiveJob::TrafficControl::Base
 
-        around_perform do |_, block|
+        around_perform do |job, block|
           if self.class.job_throttling.present?
             lock_options = {
               resources: self.class.job_throttling[:threshold],
               stale_lock_expiration: self.class.job_throttling[:period]
             }
 
-            with_lock_client(self.class.throttling_key, lock_options) do |client|
+            with_lock_client(self.class.throttling_lock_key(job), lock_options) do |client|
               token = client.lock
 
               if token
                 block.call
               elsif self.class.job_throttling[:drop]
-                drop("throttling".freeze)
+                drop("throttling")
               else
                 period = self.class.job_throttling[:period]
-                reenqueue(period...period*5, "throttling".freeze)
+                reenqueue(period...(period * 5), "throttling")
               end
             end
           else

data/lib/active_job/traffic_control/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveJob
   module TrafficControl
-    VERSION = "0.1.0".freeze
+    VERSION = "0.1.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activejob-traffic_control
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Nick Elser
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-30 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob