sidekiq-throttled 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89651103d182029649562546de86fa491ac2fd78
-  data.tar.gz: b5d7b35e556a536c6d721d1332d66605120f5918
+  metadata.gz: b39d91ca9d489440aa46f943c0bfb4dafd977621
+  data.tar.gz: 754e0213ad9081a626f50d7711a4d8de7076e15e
 SHA512:
-  metadata.gz: a3a1c17f1b72f7e9afc361265519bf067b6460474b9396d19369c06c4d6a509e973500d5b9016b97ad948f753ab24ce18ff573f1d97d11f2649ae4c1471a0a72
-  data.tar.gz: 27e73f96f33a6c3acaaa0eb7b8ae25f6c5672cb8d57763df7e9a0cab32bd679184eaad46623b23f9e6de158a6ec0d9ace231e8f7b377d4e6dee0eed6ca2b29af
+  metadata.gz: ba2a4dcb2313576ac14576740e53ec1e90fe1e71b9c2edc843ac744514ee550628d5b85a7351c835ba4786ec1aa61de173ee9ae98df9da6045dbb419bcc102f6
+  data.tar.gz: 5e07672a509a76896da044455a53569a57c9dca5bb017384fb1fdc1a6e97115a54c7d52351b75540a40b0d94763a1fbde1a120f52fb0a605922dcabd34d10eab

data/CHANGES.md

@@ -1,3 +1,10 @@
+## 0.4.0 (2016-05-17)
+
+* [#14](https://github.com/sensortower/sidekiq-throttled/pull/14)
+  Support dynamic configuration of limits and periods.
+  ([@azach], [@ixti])
+
+
 ## 0.3.2 (2016-05-16)
 
 * [#13](https://github.com/sensortower/sidekiq-throttled/issues/13)
@@ -34,3 +41,4 @@
 [@ixti]: https://github.com/ixti
 [@fhwang]: https://github.com/fhwang
 [@palanglung]: https://github.com/palanglung
+[@azach]: https://github.com/azach

data/README.md

@@ -12,21 +12,17 @@ Concurrency and threshold throttling for [Sidekiq](https://github.com/mperham/si
 
 Add this line to your application's Gemfile:
 
-```ruby
+``` ruby
 gem "sidekiq-throttled"
 ```
 
 And then execute:
 
-```
-$ bundle
-```
+    $ bundle
 
 Or install it yourself as:
 
-```
-$ gem install sidekiq-throttled
-```
+    $ gem install sidekiq-throttled
 
 
 ## Usage
@@ -85,6 +81,40 @@ class MyWorker
 end
 ```
 
+You can also supply dynamic values for limits and periods by supplying a proc
+for these values. The proc will be evaluated at the time the job is fetched
+and will receive the same arguments that are passed to the job.
+
+``` ruby
+class MyWorker
+  include Sidekiq::Worker
+  include Sidekiq::Throttled::Worker
+
+  sidekiq_options :queue => :my_queue
+
+  sidekiq_throttle({
+    # Allow maximum 1000 concurrent jobs of this class at a time for VIPs and 10 for all other users.
+    :concurrency => {
+      :limit      => ->(user_id) { User.vip?(user_id) ? 1_000 : 10 },
+      :key_suffix => ->(user_id) { User.vip?(user_id) ? "vip" : "std" }
+    },
+    # Allow 1000 jobs/hour to be processed for VIPs and 10/day for all others
+    :threshold   => {
+      :limit      => ->(user_id) { User.vip?(user_id) ? 1_000 : 10 },
+      :period     => ->(user_id) { User.vip?(user_id) ? 1.hour : 1.day },
+      :key_suffix => ->(user_id) { User.vip?(user_id) ? "vip" : "std" }
+  })
+
+  def perform(user_id)
+    # ...
+  end
+end
+```
+
+**NB** Don't forget to specify `:key_suffix` and make it return different values
+if you are using dynamic limit/period options. Otherwise you risk getting into
+some trouble.
+
 
 ## Supported Ruby Versions
 

data/lib/sidekiq/throttled/registry.rb

@@ -80,7 +80,7 @@ module Sidekiq
         def each_with_static_keys
           return to_enum(__method__) unless block_given?
           @strategies.each do |name, strategy|
-            yield(name, strategy) unless strategy.dynamic_keys?
+            yield(name, strategy) unless strategy.dynamic?
           end
         end
       end

data/lib/sidekiq/throttled/strategy.rb

@@ -42,9 +42,12 @@ module Sidekiq
         raise ArgumentError, "Neither :concurrency nor :threshold given"
       end
 
-      def dynamic_keys?
-        (@concurrency && @concurrency.dynamic_keys?) ||
-          (@threshold && @threshold.dynamic_keys?)
+      # @return [Boolean] whenever strategy has dynamic config
+      def dynamic?
+        return true if @concurrency && @concurrency.dynamic?
+        return true if @threshold && @threshold.dynamic?
+
+        false
       end
 
       # @return [Boolean] whenever job is throttled or not.

data/lib/sidekiq/throttled/strategy/concurrency.rb

@@ -17,31 +17,34 @@ module Sidekiq
         SCRIPT = Script.new File.read "#{__dir__}/concurrency.lua"
         private_constant :SCRIPT
 
-        # @!attribute [r] limit
-        #   @return [Integer] Amount of allwoed concurrent job processors
-        attr_reader :limit
-
         # @param [#to_s] strategy_key
         # @param [Hash] opts
-        # @option opts [#to_i] :limit Amount of allwoed concurrent jobs
+        # @option opts [#to_i] :limit Amount of allowed concurrent jobs
         #   processors running for given key
         # @option opts [#to_i] :ttl (15 minutes) Concurrency lock TTL
         #   in seconds
         # @option opts :key_suffix Proc for dynamic key suffix.
         def initialize(strategy_key, opts)
-          @base_key = "#{strategy_key}:concurrency".freeze
-          @limit = opts.fetch(:limit).to_i
-          @ttl = opts.fetch(:ttl, 900).to_i
+          @base_key   = "#{strategy_key}:concurrency".freeze
+          @limit      = opts.fetch(:limit)
+          @ttl        = opts.fetch(:ttl, 900).to_i
           @key_suffix = opts[:key_suffix]
         end
 
-        def dynamic_keys?
-          @key_suffix
+        # @return [Integer] Amount of allowed concurrent job processors
+        def limit(job_args = nil)
+          return @limit.to_i unless @limit.respond_to? :call
+          @limit.call(*job_args).to_i
+        end
+
+        # @return [Boolean] Whenever strategy has dynamic config
+        def dynamic?
+          @key_suffix || @limit.respond_to?(:call)
         end
 
         # @return [Boolean] whenever job is throttled or not
         def throttled?(jid, *job_args)
-          1 == SCRIPT.eval([key(job_args)], [@limit, @ttl, jid.to_s])
+          1 == SCRIPT.eval([key(job_args)], [limit(job_args), @ttl, jid.to_s])
         end
 
         # @return [Integer] Current count of jobs

data/lib/sidekiq/throttled/strategy/threshold.rb

@@ -13,7 +13,7 @@ module Sidekiq
         # Logic behind the scene can be described in following pseudo code:
         #
         #     def exceeded?
-        #       @limit <= LLEN(@key) && NOW - LINDEX(@key, -1) < @period
+        #       limit <= LLEN(@key) && NOW - LINDEX(@key, -1) < @period
         #     end
         #
         #     def increase!
@@ -29,32 +29,40 @@ module Sidekiq
         SCRIPT = Script.new File.read "#{__dir__}/threshold.lua"
         private_constant :SCRIPT
 
-        # @!attribute [r] limit
-        #   @return [Integer] Amount of jobs allowed per period
-        attr_reader :limit
-
-        # @!attribute [r] period
-        #   @return [Float] Period in seconds
-        attr_reader :period
-
         # @param [#to_s] strategy_key
         # @param [Hash] opts
         # @option opts [#to_i] :limit Amount of jobs allowed per period
         # @option opts [#to_f] :period Period in seconds
         def initialize(strategy_key, opts)
-          @base_key = "#{strategy_key}:threshold".freeze
-          @limit  = opts.fetch(:limit).to_i
-          @period = opts.fetch(:period).to_f
+          @base_key   = "#{strategy_key}:threshold".freeze
+          @limit      = opts.fetch(:limit)
+          @period     = opts.fetch(:period)
           @key_suffix = opts[:key_suffix]
         end
 
-        def dynamic_keys?
-          @key_suffix
+        # @return [Integer] Amount of jobs allowed per period
+        def limit(job_args = nil)
+          return @limit.to_i unless @limit.respond_to? :call
+          @limit.call(*job_args).to_i
+        end
+
+        # @return [Float] Period in seconds
+        def period(job_args = nil)
+          return @period.to_f unless @period.respond_to? :call
+          @period.call(*job_args).to_f
+        end
+
+        # @return [Boolean] Whenever strategy has dynamic config
+        def dynamic?
+          @key_suffix || @limit.respond_to?(:call) || @period.respond_to?(:call)
         end
 
         # @return [Boolean] whenever job is throttled or not
         def throttled?(*job_args)
-          1 == SCRIPT.eval([key(job_args)], [@limit, @period, Time.now.to_f])
+          key = key(job_args)
+          limit = limit(job_args)
+          period = period(job_args)
+          1 == SCRIPT.eval([key], [limit, period, Time.now.to_f])
         end
 
         # @return [Integer] Current count of jobs

data/lib/sidekiq/throttled/version.rb

@@ -3,6 +3,6 @@
 module Sidekiq
   module Throttled
     # Gem version
-    VERSION = "0.3.2".freeze
+    VERSION = "0.4.0".freeze
   end
 end

data/lib/sidekiq/throttled/web/stats.rb

@@ -14,8 +14,8 @@ module Sidekiq
 
         # @param [Strategy::Concurrency, Strategy::Threshold] strategy
         def initialize(strategy)
-          if strategy && strategy.dynamic_keys?
-            raise ArgumentError, "Can't handle strategies with dynamic keys"
+          if strategy && strategy.dynamic?
+            raise ArgumentError, "Can't handle dynamic strategies"
           end
           @strategy = strategy
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-throttled
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Alexey V Zapparov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-16 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -56,7 +56,6 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
-- bin/setup
 - gemfiles/sidekiq_3.x.gemfile
 - gemfiles/sidekiq_4.0.gemfile
 - gemfiles/sidekiq_4.1.gemfile

data/bin/setup

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install