sidekiq-throttler 0.1.0

data/.gitignore

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

data/.pryrc

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require 'pathname'
+$LOAD_PATH.unshift(Pathname.getwd.join('lib').to_s)
+require 'sidekiq/throttler'
+
+def reload!
+  Dir["#{Dir.pwd}/lib/**/*.rb"].each { |f| load f }
+end

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode
+  - 2.0.0
+branches:
+  only:
+    - master
+notifications:
+  email:
+    recipients:
+      - gabriel@codeconcoction.com
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: rbx-19mode
+    - rvm: 2.0.0

data/.yardopts

@@ -0,0 +1,3 @@
+--title 'Sidekiq::Throttler Documentation'
+--charset utf-8
+--markup markdown

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (December 13, 2012)
+
+* Initial release.

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,16 @@
+guard 'bundler' do
+  watch('Gemfile')
+  watch('sidekiq-throttler.gemspec')
+end
+
+guard 'rspec' do
+  watch(%r{^spec/app/.+_worker\.rb$}) { 'spec' }
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { 'spec' }
+end
+
+guard 'yard' do
+  watch(%r{app/.+\.rb})
+  watch(%r{lib/.+\.rb})
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Gabriel Evans
+
+MIT License
+
+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,79 @@
+# Sidekiq::Throttler
+
+[![Build Status](https://secure.travis-ci.org/gevans/sidekiq-throttler.png)](http://travis-ci.org/gevans/sidekiq-throttler)
+[![Dependency Status](https://gemnasium.com/gevans/sidekiq-throttler.png)](https://gemnasium.com/gevans/sidekiq-throttler)
+
+Sidekiq::Throttler is a middleware for Sidekiq that adds the ability to rate
+limit job execution on a per-worker basis.
+
+## Compatibility
+
+Sidekiq::Throttler is tested against MRI 1.9.3.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sidekiq-throttler'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sidekiq-throttler
+
+## Configuration
+
+In a Rails initializer or wherever you've configured Sidekiq, add
+Sidekiq::Throttler to your server middleware:
+
+```ruby
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Throttler
+  end
+end
+```
+
+## Usage
+
+In a worker, specify a threshold (maximum jobs) and period for throttling:
+
+```ruby
+class MyWorker
+  include Sidekiq::Worker
+
+  sidekiq_options throttle: { threshold: 50, period: 1.hour }
+
+  def perform(user_id)
+    # Do some heavy API interactions.
+  end
+end
+```
+
+In the above example, when the number of executed jobs for the worker exceeds
+50 in an hour, remaining jobs will be delayed.
+
+If throttling is per-user, for example, you can specify a `Proc` for `key` which
+accepts the arguments passed to your worker's `perform` method:
+
+```ruby
+sidekiq_options throttle: { threshold: 20, period: 1.day, key: ->{ |user_id| user_id } }
+```
+
+In the above example, jobs are throttled for each user when they exceed 20 in a
+day.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+MIT Licensed. See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+desc 'Start Pry with runtime dependencies loaded'
+task :console, :script do |t, args|
+  command  = 'bundle exec pry'
+  command += "-r #{args[:script]}" if args[:script]
+  sh command
+end

data/lib/sidekiq/throttler/rate_limit.rb

@@ -0,0 +1,202 @@
+module Sidekiq
+  class Throttler
+    ##
+    # Handles the tracking of rate limits.
+    #
+    # TODO: Consider reducing `threshold` and `period` to smooth out job
+    # executions so that "24 jobs every 1 hour" becomes "1 job every 2 minutes
+    # and 30 seconds"
+    class RateLimit
+
+      ##
+      # @return [Sidekiq::Worker]
+      #   The worker to rate limit.
+      attr_reader :worker
+
+      ##
+      # @return [Array]
+      #   The message payload for the current job.
+      attr_reader :payload
+
+      ##
+      # @return [String]
+      #   The queue to rate limit.
+      attr_reader :queue
+
+      ##
+      # @param [Sidekiq::Worker] worker
+      #   The worker to rate limit.
+      #
+      # @param [Array<Object>] payload
+      #   The message payload for the current job.
+      #
+      # @param [String] queue
+      #   The queue to rate limit.
+      def initialize(worker, payload, queue)
+        @worker = worker
+        @payload = payload
+        @queue = queue
+      end
+
+      ##
+      # Fetch the number of jobs executed.
+      #
+      # @return [Integer]
+      #   The current number of jobs executed.
+      def count
+        self.class.count(self)
+      end
+
+      ##
+      # Increment the count of jobs executed.
+      #
+      # @return [Integer]
+      #   The current number of jobs executed.
+      def increment
+        self.class.increment(self)
+      end
+
+      ##
+      # Returns the rate limit options for the current running worker.
+      #
+      # @return [{String => Float, Integer}]
+      def options
+        @options ||= (worker.class.get_sidekiq_options['throttle'] || {}).stringify_keys
+      end
+
+      ##
+      # @return [Integer]
+      #   The number of jobs that are allowed within the `period`.
+      def threshold
+        @threshold ||= options['threshold'].to_i
+      end
+
+      ##
+      # @return [Float]
+      #   The number of seconds in the rate limit period.
+      def period
+        @period ||= options['period'].to_f
+      end
+
+      ##
+      # @return [Symbol]
+      #   The key name used when storing counters for jobs.
+      def key
+        @key ||= if options['key']
+          options['key'].respond_to?(:call) ? options['key'].call(*payload) : options['key']
+        else
+          "#{@worker.class.to_s.underscore.gsub('/', ':')}:#{@queue}"
+        end
+      end
+
+      ##
+      # Check if rate limiting options were correctly specified on the worker.
+      #
+      # @return [true, false]
+      def can_throttle?
+        [threshold, period].select(&:zero?).empty?
+      end
+
+      ##
+      # Check if rate limit has exceeded the threshold.
+      #
+      # @return [true, false]
+      def exceeded?
+        count >= threshold
+      end
+
+      ##
+      # Check if rate limit is within the threshold.
+      #
+      # @return [true, false]
+      def within_bounds?
+        !exceeded?
+      end
+
+      ##
+      # Set a callback to be executed when {#execute} is called and the rate
+      # limit has not exceeded the threshold.
+      def within_bounds(&block)
+        @within_bounds = block
+      end
+
+      ##
+      # Set a callback to be executed when {#execute} is called and the rate
+      # limit has exceeded the threshold.
+      #
+      # @yieldparam [Integer] delay
+      #   Delay in seconds to requeue job for.
+      def exceeded(&block)
+        @exceeded = block
+      end
+
+      ##
+      # Executes a callback ({#within_bounds}, or {#exceeded}) depending on the
+      # state of the rate limit.
+      def execute
+        return @within_bounds.call unless can_throttle?
+
+        if exceeded?
+          @exceeded.call(period)
+        else
+          increment
+          @within_bounds.call
+        end
+      end
+
+      ##
+      # Reset the tracking of job executions.
+      def self.reset!
+        @executions = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      private
+
+      ##
+      # Fetch the number of jobs executed by the provided `RateLimit`.
+      #
+      # @param [RateLimit] limiter
+      #
+      # @return [Integer]
+      #   The current number of jobs executed.
+      def self.count(limiter)
+        Thread.exclusive do
+          prune(limiter)
+          executions[limiter.key].length
+        end
+      end
+
+      ##
+      # Increment the count of jobs executed by the provided `RateLimit`.
+      #
+      # @param [RateLimit] limiter
+      #
+      # @return [Integer]
+      #   The current number of jobs executed.
+      def self.increment(limiter)
+        Thread.exclusive do
+          executions[limiter.key] << Time.now
+        end
+        count(limiter)
+      end
+
+      ##
+      # A hash storing job executions as timestamps for each throttled worker.
+      def self.executions
+        @executions || reset!
+      end
+
+      ##
+      # Remove old entries for the provided `RateLimit`.
+      #
+      # @param [RateLimit] limiter
+      #   The rate limit to prune.
+      def self.prune(limiter)
+        executions[limiter.key].select! do |execution|
+          (Time.now - execution) < limiter.period
+        end
+      end
+
+    end # RateLimit
+  end # Throttler
+end # Sidekiq

data/lib/sidekiq/throttler/version.rb

@@ -0,0 +1,5 @@
+module Sidekiq
+  class Throttler
+    VERSION = '0.1.0'
+  end
+end

data/lib/sidekiq/throttler.rb

@@ -0,0 +1,41 @@
+require 'sidekiq'
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'sidekiq/throttler/version'
+require 'sidekiq/throttler/rate_limit'
+
+module Sidekiq
+  ##
+  # Sidekiq server middleware. Throttles jobs when they exceed limits specified
+  # on the worker. Jobs that exceed the limit are requeued with a delay.
+  class Throttler
+
+    ##
+    # Passes the worker, arguments, and queue to {RateLimit} and either yields
+    # or requeues the job depending on whether the worker is throttled.
+    #
+    # @param [Sidekiq::Worker] worker
+    #   The worker the job belongs to.
+    #
+    # @param [Hash] msg
+    #   The job message.
+    #
+    # @param [String] queue
+    #   The current queue.
+    def call(worker, msg, queue)
+      rate_limit = RateLimit.new(worker, msg['args'], queue)
+
+      rate_limit.within_bounds do
+        yield
+      end
+
+      rate_limit.exceeded do |delay|
+        worker.class.perform_in(delay, *msg['args'])
+      end
+
+      rate_limit.execute
+    end
+
+  end # Throttler
+end # Sidekiq

data/lib/sidekiq-throttler.rb

@@ -0,0 +1 @@
+require 'sidekiq/throttler'

data/sidekiq-throttler.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sidekiq/throttler/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'sidekiq-throttler'
+  gem.version       = Sidekiq::Throttler::VERSION
+  gem.authors       = ['Gabriel Evans']
+  gem.email         = ['gabriel@codeconcoction.com']
+  gem.description   = %q{Sidekiq middleware that adds the ability to rate limit job execution.}
+  gem.summary       = %q{Sidekiq::Throttler is a middleware for Sidekiq that adds the ability to rate limit job execution on a per-worker basis.}
+  gem.homepage      = 'https://github.com/gevans/sidekiq-throttler'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'sidekiq', '>= 2.5', '< 3.0'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'redcarpet'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec-redis_helper'
+  gem.add_development_dependency 'timecop'
+  gem.add_development_dependency 'simplecov'
+
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-bundler'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'guard-yard'
+  gem.add_development_dependency 'rb-fsevent'
+  gem.add_development_dependency 'rb-inotify'
+  gem.add_development_dependency 'growl'
+end

data/spec/app/workers/custom_key_worker.rb

@@ -0,0 +1,9 @@
+class CustomKeyWorker
+  include Sidekiq::Worker
+
+  sidekiq_options throttle: { threshold: 10, period: 1.minute, key: 'winning' }
+
+  def perform(name)
+    puts "#{name} is winning!"
+  end
+end

data/spec/app/workers/lolz_worker.rb

@@ -0,0 +1,9 @@
+class LolzWorker
+  include Sidekiq::Worker
+
+  sidekiq_options throttle: { threshold: 10, period: 1.minute }
+
+  def perform(name)
+    puts "OHAI #{name.upcase}!"
+  end
+end

data/spec/app/workers/proc_worker.rb

@@ -0,0 +1,9 @@
+class ProcWorker
+  include Sidekiq::Worker
+
+  sidekiq_options throttle: { threshold: 10, period: 1.minute, key: Proc.new { |*args| args.join(':') } }
+
+  def perform(*args)
+    puts args.first
+  end
+end

data/spec/app/workers/regular_worker.rb

@@ -0,0 +1,7 @@
+class RegularWorker
+  include Sidekiq::Worker
+
+  def perform(name)
+    puts "..."
+  end
+end

data/spec/sidekiq/throttler/rate_limit_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+
+describe Sidekiq::Throttler::RateLimit do
+
+  let(:worker_class) do
+    LolzWorker
+  end
+
+  let(:worker) do
+    worker_class.new
+  end
+
+  let(:payload) do
+    ['world']
+  end
+
+  let(:queue) do
+    'meow'
+  end
+
+  subject(:rate_limit) do
+    described_class.new(worker, payload, 'meow')
+  end
+
+  describe '.new' do
+
+    it 'initializes with a provided worker' do
+      rate_limit.worker.should eq(worker)
+    end
+
+    it 'initializes with provided payload' do
+      rate_limit.payload.should eq(payload)
+    end
+
+    it 'initializes with a provided queue' do
+      rate_limit.queue.should eq('meow')
+    end
+  end
+
+  describe '#options' do
+
+    it 'retrieves throttle options from the worker' do
+      worker_class.get_sidekiq_options.should_receive(:[]).with('throttle')
+      rate_limit.options
+    end
+
+    it 'stringifies the option keys' do
+      worker_class.get_sidekiq_options['throttle'].should_receive(:stringify_keys)
+      rate_limit.options
+    end
+
+    it 'caches the returned options' do
+      rate_limit.options.object_id.should eq(rate_limit.options.object_id)
+    end
+
+    context 'when the worker specifies no throttle options' do
+
+      let(:worker_class) do
+        Class.new do
+          include Sidekiq::Worker
+        end
+      end
+
+      it 'returns an empty hash' do
+        rate_limit.options.should eq({})
+      end
+    end
+  end
+
+  describe '#threshold' do
+
+    it 'retrieves the threshold from #options' do
+      rate_limit.options['threshold'] = 26
+      rate_limit.threshold.should eq(26)
+    end
+
+    it 'converts the threshold to an integer' do
+      rate_limit.options['threshold'] = '33'
+      rate_limit.threshold.should be_a(Integer)
+    end
+
+    it 'caches the returned integer' do
+      rate_limit.threshold.object_id.should eq(rate_limit.threshold.object_id)
+    end
+  end
+
+  describe '#period' do
+
+    it 'retrieves the period from #options' do
+      rate_limit.options['period'] = 10.0
+      rate_limit.period.should eq(10.0)
+    end
+
+    it 'converts the period to a float' do
+      rate_limit.options['period'] = 27
+      rate_limit.period.should be_a(Float)
+    end
+
+    it 'caches the returned float' do
+      rate_limit.period.object_id.should eq(rate_limit.period.object_id)
+    end
+  end
+
+  describe '#key' do
+
+    let(:worker_class) do
+      CustomKeyWorker
+    end
+
+    it 'caches the key from the worker' do
+      rate_limit.key.object_id.should eq(rate_limit.key.object_id)
+    end
+
+    context 'when key is a string' do
+
+      it 'returns the key as a symbol' do
+        rate_limit.key.should eq('winning')
+      end
+    end
+
+    context 'when key is a Proc' do
+
+      let(:worker_class) do
+        ProcWorker
+      end
+
+      let(:payload) do
+        ['wat', 'is', 'this']
+      end
+
+      it 'returns the result of the called Proc' do
+        rate_limit.key.should eq('wat:is:this')
+      end
+    end
+  end
+
+  describe '#can_throttle?' do
+
+    context 'when options are correctly specified' do
+
+      it 'returns true' do
+        rate_limit.can_throttle?.should be_true
+      end
+    end
+
+    %w(threshold period).each do |method|
+
+      context "when ##{method} is zero" do
+
+        it 'returns false' do
+          rate_limit.stub(method.to_sym).and_return(0)
+          rate_limit.can_throttle?.should be_false
+        end
+      end
+    end
+  end
+
+  describe '#exceeded?' do
+
+    context 'when #count is equal to #threshold' do
+
+      it 'returns true' do
+        rate_limit.should_receive(:count).and_return(rate_limit.threshold)
+        rate_limit.should be_exceeded
+      end
+    end
+
+    context 'when #count is greater than #threshold' do
+
+      it 'returns true' do
+        rate_limit.should_receive(:count).and_return(rate_limit.threshold + 1)
+        rate_limit.should be_exceeded
+      end
+    end
+
+    context 'when #count is less than #threshold' do
+
+      it 'returns false' do
+        rate_limit.should_receive(:count).and_return(0)
+        rate_limit.should_not be_exceeded
+      end
+    end
+  end
+
+  describe '#within_bounds?' do
+
+    it 'returns the opposite of #exceeded?' do
+      rate_limit.should_receive(:exceeded?).and_return(true)
+      rate_limit.should_not be_within_bounds
+      rate_limit.should_receive(:exceeded?).and_return(false)
+      rate_limit.should be_within_bounds
+    end
+  end
+
+  describe '#exceeded' do
+
+    it 'accepts a block as a callback' do
+      rate_limit.exceeded { 'rawr' }
+    end
+  end
+
+  describe '#within_bounds' do
+
+    it 'accepts a block as a callback' do
+      rate_limit.within_bounds { 'grr' }
+    end
+  end
+
+  describe '#execute' do
+
+    context 'when rate limit cannot be throttled' do
+
+      before do
+        rate_limit.should_receive(:can_throttle?).and_return(false)
+      end
+
+      it 'calls the within bounds callback' do
+        callback = Proc.new {}
+        callback.should_receive(:call)
+
+        rate_limit.within_bounds(&callback)
+        rate_limit.execute
+      end
+
+      it 'does not increment the counter' do
+        rate_limit.within_bounds {}
+
+        rate_limit.should_not_receive(:increment)
+        rate_limit.execute
+      end
+    end
+
+    context 'when rate limit is exceeded' do
+
+      before do
+        rate_limit.should_receive(:exceeded?).and_return(true)
+      end
+
+      it 'calls the exceeded callback with the configured #period' do
+        callback = Proc.new {}
+        callback.should_receive(:call).with(rate_limit.period)
+
+        rate_limit.exceeded(&callback)
+        rate_limit.execute
+      end
+    end
+
+    context 'when rate limit is within bounds' do
+
+      it 'increments the counter' do
+        rate_limit.within_bounds {}
+
+        rate_limit.should_receive(:increment)
+        rate_limit.execute
+      end
+
+      it 'calls the within bounds callback' do
+        callback = Proc.new {}
+        callback.should_receive(:call)
+
+        rate_limit.within_bounds(&callback)
+        rate_limit.execute
+      end
+    end
+  end
+
+  describe '#count' do
+
+    context 'when no jobs have executed' do
+
+      it 'returns 0' do
+        rate_limit.count.should be_zero
+      end
+    end
+  end
+
+  describe '#increment' do
+
+    it 'increments #count by one' do
+      Timecop.freeze do
+        expect { rate_limit.increment }.to change{ rate_limit.count }.by(1)
+      end
+    end
+
+    context 'when #period has passed' do
+
+      it 'removes old increments' do
+        rate_limit.options['period'] = 5
+
+        Timecop.freeze
+
+        20.times do
+          Timecop.travel(1.second.from_now)
+          rate_limit.increment
+        end
+
+        rate_limit.count.should eq(5)
+      end
+    end
+  end
+end

data/spec/sidekiq/throttler_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Sidekiq::Throttler do
+
+  subject(:throttler) do
+    described_class.new
+  end
+
+  let(:worker) do
+    LolzWorker.new
+  end
+
+  let(:message) do
+    {
+      args: 'Clint Eastwood'
+    }
+  end
+
+  let(:queue) do
+    'default'
+  end
+
+  describe '#call' do
+
+    it 'instantiates a rate limit with the worker, args, and queue' do
+      rate_limit = Sidekiq::Throttler::RateLimit.new(worker, message['args'], queue)
+      Sidekiq::Throttler::RateLimit.should_receive(:new).with(
+        worker, message['args'], queue
+      ).and_return(rate_limit)
+
+      throttler.call(worker, message, queue) {}
+    end
+
+    it 'yields in RateLimit#within_bounds' do
+      expect { |b| throttler.call(worker, message, queue, &b) }.to yield_with_no_args
+    end
+
+    it 'calls RateLimit#execute' do
+      Sidekiq::Throttler::RateLimit.any_instance.should_receive(:execute)
+      throttler.call(worker, message, queue)
+    end
+
+    context 'when rate limit is exceeded' do
+
+      it 'requeues the job with a delay' do
+        Sidekiq::Throttler::RateLimit.any_instance.should_receive(:exceeded?).and_return(true)
+        worker.class.should_receive(:perform_in).with(1.minute, *message['args'])
+        throttler.call(worker, message, queue)
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format progress

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+WORKERS = File.join(File.dirname(__FILE__), 'app', 'workers')
+$LOAD_PATH.unshift(WORKERS)
+
+unless ENV['CI']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end
+
+require 'rspec'
+require 'timecop'
+
+require 'sidekiq/throttler'
+
+# Autoload every worker for the test suite that sits in spec/app/workers
+Dir[File.join(WORKERS, '*.rb')].sort.each do |file|
+  name = File.basename(file, '.rb')
+  autoload name.camelize.to_sym, name
+end
+
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before(:each) do
+    Sidekiq::Throttler::RateLimit.reset!
+  end
+end
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/spec/support/sidekiq.rb

@@ -0,0 +1,20 @@
+require 'sidekiq/util'
+Sidekiq.logger.level = Logger::ERROR
+
+require 'rspec-redis_helper'
+RSpec::RedisHelper::CONFIG = { :url => 'redis://localhost/15', :namespace => 'testy' }
+
+require 'sidekiq/redis_connection'
+REDIS = Sidekiq::RedisConnection.create(RSpec::RedisHelper::CONFIG)
+
+RSpec.configure do |spec|
+  spec.include RSpec::RedisHelper, redis: true
+
+  # clean the Redis database around each run
+  # @see https://www.relishapp.com/rspec/rspec-core/docs/hooks/around-hooks
+  spec.around( :each, redis: true ) do |example|
+    with_clean_redis do
+      example.run
+    end
+  end
+end

metadata

@@ -0,0 +1,364 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-throttler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Gabriel Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-redis_helper
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sidekiq middleware that adds the ability to rate limit job execution.
+email:
+- gabriel@codeconcoction.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pryrc
+- .travis.yml
+- .yardopts
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sidekiq-throttler.rb
+- lib/sidekiq/throttler.rb
+- lib/sidekiq/throttler/rate_limit.rb
+- lib/sidekiq/throttler/version.rb
+- sidekiq-throttler.gemspec
+- spec/app/workers/custom_key_worker.rb
+- spec/app/workers/lolz_worker.rb
+- spec/app/workers/proc_worker.rb
+- spec/app/workers/regular_worker.rb
+- spec/sidekiq/throttler/rate_limit_spec.rb
+- spec/sidekiq/throttler_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/support/sidekiq.rb
+homepage: https://github.com/gevans/sidekiq-throttler
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2112495299373871691
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2112495299373871691
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Sidekiq::Throttler is a middleware for Sidekiq that adds the ability to rate
+  limit job execution on a per-worker basis.
+test_files:
+- spec/app/workers/custom_key_worker.rb
+- spec/app/workers/lolz_worker.rb
+- spec/app/workers/proc_worker.rb
+- spec/app/workers/regular_worker.rb
+- spec/sidekiq/throttler/rate_limit_spec.rb
+- spec/sidekiq/throttler_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/support/sidekiq.rb
+has_rdoc: