sidekiq-throttled 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76a708f284e2c4b3c3a65477f8893420854aeca4
+  data.tar.gz: 8c5c83a1d64063af01170067819bf167fe710bfe
+SHA512:
+  metadata.gz: 6e703df521b67bccb01d0e022dd83376ac6d9cd68d57e7603f36212b7e8969a0128e5119df0e6224c9da813308a743e8ffb1302f44142adfc82b43b163c82978
+  data.tar.gz: b0b142ad1f692d962c7ffa63027c309350d5c0258a05d5b9cb1adcc2eb1a491244d0d9dd1191ef1348ed2930f020a1f6a66bc902ff6ab4bd2814c0b98a30233e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,5 @@
+--backtrace
+--color
+--format=documentation
+--order random
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,72 @@
+## Styles ######################################################################
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+# Broken (2014-12-15). Use `yardstick` gem instead.
+# See: https://github.com/bbatsov/rubocop/issues/947
+# TODO: Enable back once cop is fixed.
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyLineBetweenDefs:
+  AllowAdjacentOneLineDefs: true
+
+Style/Encoding:
+  EnforcedStyle: when_needed
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+# New lambda syntax is as ugly to me as new syntax of Hash.
+Style/Lambda:
+  Enabled: false
+
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+# IMHO `%r{foo/bar}` looks way more cleaner than `/foo\/bar/`.
+# Enabling this cop also makes Guardfile (which is full of pathname regexps)
+# look absolutley (style) inconsistent and terrible. Thus it should be on
+# developer's choice whenever to user `%r` or not. Just like we don't enforce
+# to use `["foo"]` over `%w(foo)` and so on.
+Style/RegexpLiteral:
+  Enabled: false
+
+# A bit useless restriction, that makes impossible aligning code like this:
+#
+#   redis do |conn|
+#     conn.hset    :k1, now
+#     conn.hincrby :k2, 123
+#   end
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+# Not all trivial readers/writers can be defined with attr_* methods
+#
+#   class Example < SimpleDelegator
+#     def __getobj__
+#       @obj
+#     end
+#
+#     def __setobj__(obj)
+#       @obj = obj
+#     end
+#   end
+Style/TrivialAccessors:
+  Enabled: false
+
+## Metrics #####################################################################
+
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.6
+before_install: gem install bundler -v 1.10.6

data/.yardopts

@@ -0,0 +1 @@
+--no-private - LICENSE.md

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in sidekiq-throttled.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 SensorTower Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# Sidekiq::Throttled
+
+Concurrency and threshold throttling for Sidekiq.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "sidekiq-throttled"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install sidekiq-throttled
+```
+
+
+## Usage
+
+Add somewhere in your app's bootstrap (e.g. `config/initializers/sidekiq.rb` if
+you are using Rails):
+
+``` ruby
+require "sidekiq/throttled"
+Sidekiq::Throttled.setup!
+```
+
+Once you've done that you can include `Sidekiq::Throttled::Worker` to your
+job classes and configure throttling:
+
+``` ruby
+class MyWorker
+  include Sidekiq::Worker
+  include Sidekiq::Throttled::Worker
+
+  sidekiq_options :queue => :my_queue
+
+  sidekiq_throttle({
+    # Allow maximum 10 concurrent jobs of this class at a time.
+    :concurrency => { :limit => 10 },
+    # Allow maximum 1K jobs being processed within one hour window.
+    :threshold => { :limit => 1_000, :period => 1.hour }
+  })
+
+  def perform
+    # ...
+  end
+end
+```
+
+
+## Contributing
+
+* Fork sidekiq-throttled on GitHub
+* Make your changes
+* Ensure all tests pass (`bundle exec rake`)
+* Send a pull request
+* If we like them we'll merge them
+* If we've accepted a patch, feel free to ask for commit access!
+
+
+## Copyright
+
+Copyright (c) 2015 SensorTower Inc.
+See LICENSE.md for further details.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+task :default => [:spec, :rubocop]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sidekiq/throttled"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sidekiq/throttled.rb

@@ -0,0 +1,72 @@
+# 3rd party
+require "sidekiq"
+
+# internal
+require "sidekiq/version"
+require "sidekiq/throttled/registry"
+require "sidekiq/throttled/worker"
+
+# @see https://github.com/mperham/sidekiq/
+module Sidekiq
+  # Concurrency and threshold throttling for Sidekiq.
+  #
+  # Just add somewhere in your bootstrap:
+  #
+  #     require "sidekiq/throttled"
+  #     Sidekiq::Throttled.setup!
+  #
+  # Once you've done that you can include {Sidekiq::Throttled::Worker} to your
+  # job classes and configure throttling:
+  #
+  #     class MyWorker
+  #       include Sidekiq::Worker
+  #       include Sidekiq::Throttled::Worker
+  #
+  #       sidekiq_options :queue => :my_queue
+  #
+  #       sidekiq_throttle({
+  #         # Allow maximum 10 concurrent jobs of this class at a time.
+  #         :concurrency => { :limit => 10 },
+  #         # Allow maximum 1K jobs being processed within one hour window.
+  #         :threshold => { :limit => 1_000, :period => 1.hour }
+  #       })
+  #
+  #       def perform
+  #         # ...
+  #       end
+  #     end
+  module Throttled
+    class << self
+      # Hooks throttler into sidekiq.
+      # @return [void]
+      def setup!
+        Sidekiq.configure_server do |config|
+          require "sidekiq/throttled/basic_fetch"
+          Sidekiq.options[:fetch] = Sidekiq::Throttled::BasicFetch
+
+          require "sidekiq/throttled/middleware"
+          config.server_middleware do |chain|
+            chain.add Sidekiq::Throttled::Middleware
+          end
+        end
+      end
+
+      # @param [String] message JSON payload of job
+      # @return [TrueClass] if job is not allowed to be processed now
+      # @return [FalseClass] otherwise
+      def throttled?(message)
+        message = JSON.parse message
+        job = message.fetch("class".freeze) { return false }
+        jid = message.fetch("jid".freeze) { return false }
+
+        Registry.get job do |strategy|
+          return strategy.throttled? jid
+        end
+
+        false
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/basic_fetch.rb

@@ -0,0 +1,63 @@
+# stdlib
+require "thread"
+
+# 3rd party
+require "celluloid"
+require "sidekiq"
+require "sidekiq/fetch"
+
+module Sidekiq
+  module Throttled
+    # Throttled version of `Sidekiq::BasicFetch` fetcher strategy.
+    class BasicFetch < ::Sidekiq::BasicFetch
+      # Class constructor
+      def initialize(*args)
+        @mutex      = Mutex.new
+        @suspended  = []
+
+        super(*args)
+      end
+
+      # @return [Sidekiq::BasicFetch::UnitOfWork, nil]
+      def retrieve_work
+        work = brpop
+        return unless work
+
+        work = ::Sidekiq::BasicFetch::UnitOfWork.new(*work)
+        return work unless Throttled.throttled? work.message
+
+        queue = "queue:#{work.queue_name}"
+
+        @mutex.synchronize { @suspended << queue }
+        Sidekiq.redis { |conn| conn.lpush(queue, work.message) }
+
+        nil
+      end
+
+      private
+
+      # Tries to pop pair of `queue` and job `message` out of sidekiq queue.
+      # @return [Array<String, String>, nil]
+      def brpop
+        if @strictly_ordered_queues
+          queues = @unique_queues.dup
+        else
+          queues = @queues.shuffle.uniq
+        end
+
+        @mutex.synchronize do
+          next if @suspended.empty?
+          queues -= @suspended
+          @suspended.clear
+        end
+
+        if queues.empty?
+          sleep Sidekiq::Fetcher::TIMEOUT
+          return
+        end
+
+        Sidekiq.redis { |conn| conn.brpop(*queues, Sidekiq::Fetcher::TIMEOUT) }
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/errors.rb

@@ -0,0 +1,6 @@
+module Sidekiq
+  module Throttled
+    # Generic class for Sidekiq::Throttled errors
+    class Error < StandardError; end
+  end
+end

data/lib/sidekiq/throttled/middleware.rb

@@ -0,0 +1,19 @@
+# internal
+require "sidekiq/throttled/registry"
+
+module Sidekiq
+  module Throttled
+    # Server middleware that notifies strategy that job was finished.
+    # @private
+    class Middleware
+      # Called within Sidekiq job processing
+      def call(_worker, msg, _queue)
+        yield
+      ensure
+        Registry.get msg["class".freeze] do |strategy|
+          strategy.finalize! msg["jid".freeze]
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/registry.rb

@@ -0,0 +1,73 @@
+# internal
+require "sidekiq/throttled/strategy"
+
+module Sidekiq
+  module Throttled
+    # Registred strategies.
+    module Registry
+      @strategies = {}
+      @aliases    = {}
+
+      class << self
+        # Adds strategy to the registry.
+        #
+        # @note prints a warning to STDERR upon duplicate strategy name
+        # @param (see Strategy#initialize)
+        # @return [Strategy]
+        def add(name, **kwargs)
+          name = name.to_s
+
+          warn "Duplicate strategy name: #{name}" if @strategies[name]
+
+          @strategies[name] = Strategy.new(name, **kwargs)
+        end
+
+        # Adds alias for existing strategy.
+        #
+        # @note prints a warning to STDERR upon duplicate strategy name
+        # @param (#to_s) new_name
+        # @param (#to_s) old_name
+        # @raise [RuntimeError] if no strategy found with `old_name`
+        # @return [Strategy]
+        def add_alias(new_name, old_name)
+          new_name = new_name.to_s
+          old_name = old_name.to_s
+
+          warn "Duplicate strategy name: #{new_name}" if @strategies[new_name]
+          fail "Strategy not found: #{old_name}" unless @strategies[old_name]
+
+          @aliases[new_name] = @strategies[old_name]
+        end
+
+        # @overload get(name)
+        #   @param [#to_s] name
+        #   @return [Strategy, nil] registred strategy
+        #
+        # @overload get(name, &block)
+        #   Yields control to the block if requested strategy was found.
+        #   @yieldparam [Strategy] strategy
+        #   @yield [strategy] Gives found strategy to the block
+        #   @return result of a block
+        def get(name)
+          strategy = @strategies[name.to_s] || @aliases[name.to_s]
+          return yield strategy if strategy && block_given?
+          strategy
+        end
+
+        # @overload each()
+        #   @return [Enumerator]
+        #
+        # @overload each(&block)
+        #   @yieldparam [String] name
+        #   @yieldparam [Strategy] strategy
+        #   @yield [strategy] Gives strategy to the block
+        #   @return [Registry]
+        def each
+          return to_enum(__method__) unless block_given?
+          @strategies.each { |*args| yield(*args) }
+          self
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/strategy.rb

@@ -0,0 +1,60 @@
+# internal
+require "sidekiq/throttled/errors"
+require "sidekiq/throttled/strategy/concurrency"
+require "sidekiq/throttled/strategy/threshold"
+
+module Sidekiq
+  module Throttled
+    # Meta-strategy that couples {Concurrency} and {Threshold} strategies.
+    class Strategy
+      # @!attribute [r] concurrency
+      #   @return [Strategy::Concurrency, nil]
+      attr_reader :concurrency
+
+      # @!attribute [r] threshold
+      #   @return [Strategy::Threshold, nil]
+      attr_reader :threshold
+
+      # @param [#to_s] key
+      # @param [Hash] concurrency Concurrency options.
+      #   See {Strategy::Concurrency#initialize} for details.
+      # @param [Hash] threshold Threshold options.
+      #   See {Strategy::Threshold#initialize} for details.
+      def initialize(key, concurrency: nil, threshold: nil)
+        base_key      = "throttled:#{key}"
+
+        @concurrency  = concurrency && Concurrency.new(base_key, concurrency)
+        @threshold    = threshold && Threshold.new(base_key, threshold)
+
+        return if @concurrency || @threshold
+
+        fail ArgumentError, "Neither :concurrency nor :threshold given"
+      end
+
+      # @return [Boolean] whenever job is throttled or not.
+      def throttled?(jid)
+        return true if @concurrency && @concurrency.throttled?(jid)
+
+        if @threshold && @threshold.throttled?
+          finalize! jid
+          return true
+        end
+
+        false
+      end
+
+      # Marks job as being processed.
+      # @return [void]
+      def finalize!(jid)
+        @concurrency && @concurrency.finalize!(jid)
+      end
+
+      # Resets count of jobs of all avaliable strategies
+      # @return [void]
+      def reset!
+        @concurrency && @concurrency.reset!
+        @threshold && @threshold.reset!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+local r, k, l, t, j = redis, KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), ARGV[3]
+if l <= r.call("SCARD", k) and 0 == r.call("SISMEMBER", k, j) then return 1 end
+r.call("SADD", k, j); r.call("EXPIRE", k, t); return 0

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

@@ -0,0 +1,59 @@
+# internal
+require "sidekiq/throttled/strategy/script"
+
+module Sidekiq
+  module Throttled
+    class Strategy
+      # Concurrency throttling strategy
+      class Concurrency
+        # LUA script used to limit fetch concurrency.
+        # Logic behind the scene can be described in following pseudo code:
+        #
+        #     return 1 if @limit <= LLEN(@key)
+        #
+        #     PUSH(@key, @jid)
+        #     return 0
+        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] base_key
+        # @param [Hash] opts
+        # @option opts [#to_i] :limit Amount of allwoed concurrent jobs
+        #   processors running for given key
+        # @option opts [#to_i] :ttl (15.minutes) Concurrency lock TTL
+        def initialize(base_key, opts)
+          @key   = "#{base_key}:concurrency".freeze
+          @keys  = [@key]
+          @limit = opts.fetch(:limit).to_i
+          @ttl   = opts.fetch(:ttl, 900).to_i
+        end
+
+        # @return [Boolean] whenever job is throttled or not
+        def throttled?(jid)
+          1 == SCRIPT.eval(@keys, [@limit, @ttl, jid.to_s])
+        end
+
+        # @return [Integer] Current count of jobs
+        def count
+          Sidekiq.redis { |conn| conn.scard(@key) }.to_i
+        end
+
+        # Resets count of jobs
+        # @return [void]
+        def reset!
+          Sidekiq.redis { |conn| conn.del(@key) }.to_i
+        end
+
+        # Remove jid from the pool of jobs in progress
+        # @return [void]
+        def finalize!(jid)
+          Sidekiq.redis { |conn| conn.srem(@key, jid.to_s) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Sidekiq
+  module Throttled
+    class Strategy
+      # Lua script executor for redis.
+      #
+      # Instead of executing script with `EVAL` everytime - loads script once
+      # and then runs it with `EVALSHA`.
+      #
+      # @private
+      class Script
+        # Script load command
+        LOAD = "load".freeze
+        private_constant :LOAD
+
+        # Redis error fired when script ID is unkown
+        NOSCRIPT = "NOSCRIPT".freeze
+        private_constant :NOSCRIPT
+
+        # @param [#to_s] source Lua script
+        def initialize(source)
+          @source = source.to_s.strip.freeze
+          @sha    = nil
+        end
+
+        # Executes script and returns result of execution
+        def eval(*args)
+          Sidekiq.redis { |conn| conn.evalsha(@sha, *args) }
+        rescue => e
+          raise unless e.message.include? NOSCRIPT
+          load_and_eval(*args)
+        end
+
+        private
+
+        # Loads script into redis cache and executes it.
+        def load_and_eval(*args)
+          Sidekiq.redis do |conn|
+            @sha = conn.script(LOAD, @source)
+            conn.evalsha(@sha, *args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+local r, k, l, p, t = redis, KEYS[1], tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
+if l <= r.call("LLEN", k) and t - r.call("LINDEX", k, -1) < p then return 1 end
+r.call("LPUSH", k, t); r.call("LTRIM", k, 0, l - 1); r.call("EXPIRE", k, p); return 0

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

@@ -0,0 +1,68 @@
+# internal
+require "sidekiq/throttled/strategy/script"
+
+module Sidekiq
+  module Throttled
+    class Strategy
+      # Threshold throttling strategy
+      # @todo Use redis TIME command instead of sending current timestamp from
+      #   sidekiq manager. See: http://redis.io/commands/time
+      class Threshold
+        # LUA script used to limit fetch threshold.
+        # Logic behind the scene can be described in following pseudo code:
+        #
+        #     def exceeded?
+        #       @limit <= LLEN(@key) && NOW - LINDEX(@key, -1) < @period
+        #     end
+        #
+        #     def increase!
+        #       LPUSH(@key, NOW)
+        #       LTRIM(@key, 0, @limit - 1)
+        #       EXPIRE(@key, @period)
+        #     end
+        #
+        #     return 1 if exceeded?
+        #
+        #     increase!
+        #     return 0
+        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] base_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(base_key, opts)
+          @key    = "#{base_key}:threshold".freeze
+          @keys   = [@key]
+          @limit  = opts.fetch(:limit).to_i
+          @period = opts.fetch(:period).to_f
+        end
+
+        # @return [Boolean] whenever job is throttled or not
+        def throttled?
+          1 == SCRIPT.eval(@keys, [@limit, @period, Time.now.to_f])
+        end
+
+        # @return [Integer] Current count of jobs
+        def count
+          Sidekiq.redis { |conn| conn.llen(@key) }.to_i
+        end
+
+        # Resets count of jobs
+        # @return [void]
+        def reset!
+          Sidekiq.redis { |conn| conn.del(@key) }
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/testing.rb

@@ -0,0 +1,10 @@
+require "sidekiq/throttled/registry"
+
+RSpec.configure do |config|
+  config.before :example do
+    Sidekiq::Throttled::Registry.instance_eval do
+      @strategies.clear
+      @aliases.clear
+    end
+  end
+end

data/lib/sidekiq/throttled/version.rb

@@ -0,0 +1,6 @@
+module Sidekiq
+  module Throttled
+    # Gem version
+    VERSION = "0.1.0".freeze
+  end
+end

data/lib/sidekiq/throttled/web.rb

@@ -0,0 +1,33 @@
+# stdlib
+require "pathname"
+
+# 3rd party
+require "sidekiq"
+require "sidekiq/web"
+
+# internal
+require "sidekiq/throttled/registry"
+require "sidekiq/throttled/web/stats"
+
+module Sidekiq
+  module Throttled
+    # Provides Sidekiq tab to monitor and reset throttled stats.
+    # @private
+    module Web
+      class << self
+        def registered(app)
+          template = Pathname.new(__FILE__).join("../web/index.html.erb").read
+          app.get("/throttled") { erb template.dup }
+
+          app.delete("/throttled/:id") do
+            Registry.get(params[:id], &:reset!)
+            redirect "#{root_path}throttled"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sidekiq::Web.register Sidekiq::Throttled::Web
+Sidekiq::Web.tabs["Throttled"] = "throttled"

data/lib/sidekiq/throttled/web/index.html.erb

@@ -0,0 +1,38 @@
+<div class="col-sm-12">
+  <div class="row header">
+    <div class="col-sm-8 pull-left">
+      <h3>Throttled</h3>
+    </div>
+  </div>
+</div>
+
+<table class="table table-hover table-bordered table-striped table-white">
+  <thead>
+    <tr>
+      <th>Name</th>
+      <th style="text-align:center;">Concurrency</th>
+      <th style="text-align:center;">Threshold</th>
+      <th></th>
+    </tr>
+  </thead>
+  <tbody>
+    <% Sidekiq::Throttled::Registry.each do |name, strategy| %>
+      <tr>
+        <td style="vertical-align:middle;"><%= name %></td>
+        <td style="vertical-align:middle;text-align:center;">
+          <%= Sidekiq::Throttled::Web::Stats.new(strategy.concurrency).to_html %>
+        </td>
+        <td style="vertical-align:middle;text-align:center;">
+          <%= Sidekiq::Throttled::Web::Stats.new(strategy.threshold).to_html %>
+        </td>
+        <td style="vertical-align:middle;text-align:center;">
+          <form action="<%= root_path %>throttled/<%= name %>" method="POST">
+            <%= csrf_tag %>
+            <input type="hidden" name="_method" value="delete" />
+            <button class="btn btn-danger" type="submit">Reset</button>
+          </form>
+        </td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

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

@@ -0,0 +1,72 @@
+module Sidekiq
+  module Throttled
+    module Web
+      # Throttle strategy stats generation helper
+      # @private
+      class Stats
+        TIME_CONVERSION = [
+          [60 * 60 * 24,  "day",    "days"],
+          [60 * 60,       "hour",   "hours"],
+          [60,            "minute", "minutes"],
+          [1,             "second", "seconds"]
+        ].freeze
+
+        # @param [Strategy::Concurrency, Strategy::Threshold] strategy
+        def initialize(strategy)
+          @strategy = strategy
+        end
+
+        # @return [String]
+        def to_html
+          return "" unless @strategy
+
+          html = humanize_integer(@strategy.limit) << " jobs"
+
+          if @strategy.respond_to? :period
+            html << " per " << humanize_duration(@strategy.period)
+          end
+
+          html << "<br />" << colorize_count(@strategy.count, @strategy.limit)
+        end
+
+        private
+
+        # @return [String]
+        def colorize_count(int, max)
+          percentile = 100.00 * int / max
+          lvl = case
+                when 80 <= percentile then "danger"
+                when 60 <= percentile then "warning"
+                else                       "success"
+                end
+
+          %(<span class="label label-#{lvl}">#{int}</span>)
+        end
+
+        # @return [String]
+        def humanize_duration(int)
+          arr = []
+
+          TIME_CONVERSION.each do |(dimension, unit, units)|
+            count = (int / dimension).to_i
+            next unless 0 < count
+            int -= count * dimension
+            arr << "#{count} #{1 == count ? unit : units}"
+          end
+
+          arr.join " "
+        end
+
+        # @return [String]
+        def humanize_integer(int)
+          digits = int.to_s.split ""
+          str    = digits.shift(digits.count % 3).join("")
+
+          str << " " << digits.shift(3).join("") while 0 < digits.count
+
+          str.strip
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/worker.rb

@@ -0,0 +1,126 @@
+# internal
+require "sidekiq/throttled/registry"
+
+module Sidekiq
+  module Throttled
+    # Adds helpers to your worker classes
+    #
+    # @example Usage
+    #
+    #     class MyWorker
+    #       include Sidekiq::Worker
+    #       include Sidekiq::Throttled::Worker
+    #
+    #       sidkiq_options :queue => :my_queue
+    #       sidekiq_throttle :threshold => { :limit => 123, :period => 1.hour }
+    #
+    #       def perform
+    #         # ...
+    #       end
+    #     end
+    #
+    # @see ClassMethods
+    module Worker
+      # Extends worker class with {ClassMethods}.
+      #
+      # @note Using `included` hook with extending worker with {ClassMethods}
+      #   in order to make API inline with `include Sidekiq::Worker`.
+      #
+      # @private
+      def self.included(worker)
+        worker.send(:extend, ClassMethods)
+      end
+
+      # Helper methods added to the singleton class of destination
+      module ClassMethods
+        # Registers some strategy for the worker.
+        #
+        # @example Allow max 123 MyWorker jobs per hour
+        #
+        #     class MyWorker
+        #       include Sidekiq::Worker
+        #       include Sidekiq::Throttled::Worker
+        #
+        #       sidekiq_throttle({
+        #         :threshold => { :limit => 123, :period => 1.hour }
+        #       })
+        #     end
+        #
+        # @example Allow max 10 concurrently running MyWorker jobs
+        #
+        #     class MyWorker
+        #       include Sidekiq::Worker
+        #       include Sidekiq::Throttled::Worker
+        #
+        #       sidekiq_throttle({
+        #         :concurrency => { :limit => 10 }
+        #       })
+        #     end
+        #
+        # @example Allow max 10 concurrent MyWorker jobs and max 123 per hour
+        #
+        #     class MyWorker
+        #       include Sidekiq::Worker
+        #       include Sidekiq::Throttled::Worker
+        #
+        #       sidekiq_throttle({
+        #         :threshold => { :limit => 123, :period => 1.hour },
+        #         :concurrency => { :limit => 10 }
+        #       })
+        #     end
+        #
+        # @see Registry.add
+        # @return [void]
+        def sidekiq_throttle(**kwargs)
+          Registry.add(self, **kwargs)
+        end
+
+        # Adds current worker to preconfigured throtttling strtegy. Allows
+        # sharing same pool for multiple workers.
+        #
+        # First of all we need to create shared throttling strategy:
+        #
+        #     # Create google_api throttling strategy
+        #     Sidekiq::Throttled::Registry.add(:google_api, {
+        #       :threshold => { :limit => 123, :period => 1.hour },
+        #       :concurrency => { :limit => 123 }
+        #     })
+        #
+        # Now we can assign it to our workers:
+        #
+        #     class FetchProfileJob
+        #       include Sidekiq::Worker
+        #       include Sidekiq::Throttled::Worker
+        #
+        #       sidekiq_throttle_as :google_api
+        #     end
+        #
+        #     class FetchCommentsJob
+        #       include Sidekiq::Worker
+        #       include Sidekiq::Throttled::Worker
+        #
+        #       sidekiq_throttle_as :google_api
+        #     end
+        #
+        # With the above configuration we ensure that there are maximum 10
+        # concurrently running jobs of FetchProfileJob or FetchCommentsJob
+        # allowed. And only 123 jobs of those are executed per hour.
+        #
+        # In other words, it will allow:
+        #
+        # - only `X` concurrent `FetchProfileJob`s
+        # - max `XX` `FetchProfileJob` per hour
+        # - only `Y` concurrent `FetchCommentsJob`s
+        # - max `YY` `FetchCommentsJob` per hour
+        #
+        # Where `(X + Y) == 10` and `(XX + YY) == 123`
+        #
+        # @see Registry.add_alias
+        # @return [void]
+        def sidekiq_throttle_as(name)
+          Registry.add_alias(self, name)
+        end
+      end
+    end
+  end
+end

data/sidekiq-throttled.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "sidekiq/throttled/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sidekiq-throttled"
+  spec.version       = Sidekiq::Throttled::VERSION
+  spec.authors       = ["Alexey V Zapparov"]
+  spec.email         = ["ixti@member.fsf.org"]
+
+  spec.summary       = "Concurrency and threshold throttling for Sidekiq."
+  spec.description   = "Concurrency and threshold throttling for Sidekiq."
+  spec.homepage      = "https://github.com/sensortower/sidekiq-throttled"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+    .reject { |f| f.match(%r{^(test|spec|features)/}) }
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency     "sidekiq", "< 4"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "sinatra", "~> 1.4", ">= 1.4.6"
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-throttled
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexey V Zapparov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.6
+description: Concurrency and threshold throttling for Sidekiq.
+email:
+- ixti@member.fsf.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sidekiq/throttled.rb
+- lib/sidekiq/throttled/basic_fetch.rb
+- lib/sidekiq/throttled/errors.rb
+- lib/sidekiq/throttled/middleware.rb
+- lib/sidekiq/throttled/registry.rb
+- lib/sidekiq/throttled/strategy.rb
+- lib/sidekiq/throttled/strategy/concurrency.lua
+- lib/sidekiq/throttled/strategy/concurrency.rb
+- lib/sidekiq/throttled/strategy/script.rb
+- lib/sidekiq/throttled/strategy/threshold.lua
+- lib/sidekiq/throttled/strategy/threshold.rb
+- lib/sidekiq/throttled/testing.rb
+- lib/sidekiq/throttled/version.rb
+- lib/sidekiq/throttled/web.rb
+- lib/sidekiq/throttled/web/index.html.erb
+- lib/sidekiq/throttled/web/stats.rb
+- lib/sidekiq/throttled/worker.rb
+- sidekiq-throttled.gemspec
+homepage: https://github.com/sensortower/sidekiq-throttled
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.3
+signing_key: 
+specification_version: 4
+summary: Concurrency and threshold throttling for Sidekiq.
+test_files: []