rack-attack-rate-limit 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae6161b3d1a8760682d587b41b570240aea058f4
-  data.tar.gz: 96c6e87f6143f46feb7c38c136a16c00fc6e7188
+  metadata.gz: 1d10bdcfab72d5a2a4b398d240d1944189da6318
+  data.tar.gz: 86f9d556c90a96e7d5a5f2e57231a8c24b602203
 SHA512:
-  metadata.gz: 4b487f260716def9aa4bba218fcbda154a214132eaaa0055cc13e6e90702f9008d2bc146fd0c00d86f4f77ac1c186c9a0f6d6898a276d2f9ad723c2f78f520b8
-  data.tar.gz: 6a34a589b16e7ea377ed4e1ec751ffee171a0897d11e6087b3f1ac339aef2bcbcb9ca1f966eadd0bb21682f273640bda3f2fd8e91441cd141a8a3689e1eceaa1
+  metadata.gz: 037cb6dee3e51d86c6f8b29f16fa6eeb64c304debabb1f8381e45bdacb239bce77b03fa11aae869bede31ca8e8955c113fc09af09d047376f315b07564761e2a
+  data.tar.gz: 97a2e8aeb2734b1c3681bd196c72b82be999641ec6a7def2ff0f76f3573fb6ea87146bf69a518cd257532a1902d8ac0b7a29b380c1bad89a99a06af03522a635

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # rack-attack-rate-limit changelog
 
+## 1.1.0
+
+* Add support for multiple throttles.
+
 ## 1.0.0
 
 * Support for Rails 4

data/README.md

@@ -26,7 +26,7 @@ bundle
 
 ## Usage
 
-Rack::Attack::RateLimit expects a Rack::Attack throttle to be defined:
+Rack::Attack::RateLimit expects at least one Rack::Attack throttle to be defined:
 
 ```ruby
 Rack::Attack.throttle('my_throttle') do |req|
@@ -34,20 +34,20 @@ Rack::Attack.throttle('my_throttle') do |req|
 end
 ```
 
-To include rate limit headers for this throttle, include the Rack::Attack::RateLimit middleware
+To include rate limit headers for throttles, include the Rack::Attack::RateLimit middleware, and provide it with the names of the throttles you want to add rate limit headers for. A single throttle name can be provided as a string, while multiple throttle names must be provided as an array of strings.
 
 For Rails 3+:
 
 ```ruby
-config.middleware.use Rack::Attack::RateLimit, throttle: 'my_throttle'
+config.middleware.use Rack::Attack::RateLimit, throttle: ['my_throttle', 'my_other_throttle']
 ```
 
-Currently, Rack::Attack::RateLimit can only be configured to return rate limit headers for a single throttle, whose name can be specified as an option.
-
 Rate limit headers are:
 
 * 'X-RateLimit-Limit' - The total number of requests allowed.
-* 'X-RateLimit-Remaining' - The number of remaining requests. 
+* 'X-RateLimit-Remaining' - The number of remaining requests.
+
+If a request triggers multiple throttles, the gem will add headers for the throttle with the lowest number of remaining requests.
 
 ## Contributing
 

data/lib/rack/attack/rate-limit.rb

@@ -41,7 +41,7 @@ module Rack
       end
 
       def throttle
-        options[:throttle] || ''
+        Array(options[:throttle]) || []
       end
 
       # Return hash of headers with Rate Limiting data
@@ -50,8 +50,9 @@ module Rack
       #
       # Returns hash
       def add_rate_limit_headers!(headers, env)
-        headers['X-RateLimit-Limit']      = rate_limit_limit(env).to_s
-        headers['X-RateLimit-Remaining']  = rate_limit_remaining(env).to_s
+        throttle_data = throttle_data_closest_to_limit(env)
+        headers['X-RateLimit-Limit']      = rate_limit_limit(throttle_data).to_s
+        headers['X-RateLimit-Remaining']  = rate_limit_remaining(throttle_data).to_s
         headers
       end
 
@@ -62,8 +63,8 @@ module Rack
       # env - Hash
       #
       # Returns Fixnum
-      def rate_limit_limit(env)
-        env[rack_attack_key][throttle][:limit]
+      def rate_limit_limit(throttle_data)
+        throttle_data[:limit]
       end
 
       # RateLimit remaining request from Rack::Attack
@@ -71,18 +72,41 @@ module Rack
       # env - Hash
       #
       # Returns Fixnum
-      def rate_limit_remaining(env)
-        rate_limit_limit(env) - env[rack_attack_key][throttle][:count]
+      def rate_limit_remaining(throttle_data)
+        rate_limit_limit(throttle_data) - throttle_data[:count]
       end
 
       # Rate Limit available method for Rack::Attack provider
-      # Checks the key identifed by options[:namespace] under the rack.attak.throttle_data env hash key
+      # Checks that at least one of the keys provided by the user are in the rack.attack.throttle_data env hash key
       #
       # env - Hash
       #
       # Returns boolean
       def rate_limit_available?(env)
-        env.key?(rack_attack_key) && env[rack_attack_key].key?(throttle)
+        env.key?(rack_attack_key) && (env[rack_attack_key].keys & throttle).any?
+      end
+
+      # Throttle Data of Interest
+      # Filters the rack.attack.throttle_data env hash key for the throttle names provided by the user
+      #
+      # env - Hash
+      #
+      # Returns Hash
+      def throttle_data_of_interest(env)
+        env[rack_attack_key].select { |k, _v| throttle.include?(k) }
+      end
+
+      # Throttle Data Closest to Limit
+      # Selects the hash in throttle_data_of_interest where the user is closest to the limit
+      #
+      # env - Hash
+      #
+      # Returns Hash
+      def throttle_data_closest_to_limit(env)
+        min_array = throttle_data_of_interest(env).min_by { |_k, v| v[:limit] - v[:count] }
+        # The min_by method returns an array of the form [key, value]
+        # We only need the values
+        min_array.last
       end
     end
   end

data/lib/rack/attack/rate-limit/version.rb

@@ -1,7 +1,7 @@
 module Rack
   class Attack
     class RateLimit
-      VERSION = '1.0.0'
+      VERSION = '1.1.0'
     end
   end
 end

data/spec/rack/attack/rate-limit_spec.rb

@@ -1,59 +1,101 @@
 require 'spec_helper'
 
 describe Rack::Attack::RateLimit do
-  
+
   include Rack::Test::Methods
-  
-  let(:throttle) { 'rack_attack_throttle' }
-  
+
+  let(:throttle_one)    { 'foo_throttle' }
+  let(:throttle_two)    { 'bar_throttle' }
+  let(:throttle_three)  { 'baz_throttle' }
+
   let(:app) do
-    use_throttle = throttle
-    Rack::Builder.new {
+    use_throttle = throttle_one
+    Rack::Builder.new do
       use Rack::Attack::RateLimit, throttle: use_throttle
-      run lambda { |env| [200, {}, 'Hello, World!'] }
-    }.to_app
-    
+      run ->(_env) { [200, {}, 'Hello, World!'] }
+    end.to_app
   end
-  
-  
+
   context 'Throttle data not present from Rack::Attack' do
-    
+
     before(:each) do
       get '/'
-    end 
-    
+    end
+
     it 'should not create RateLimit headers' do
       last_response.header.key?('X-RateLimit-Limit').should be false
       last_response.header.key?('X-RateLimit-Remaining').should be false
     end
-    
+
   end
 
   context 'Throttle data present from Rack::Attack' do
-    
-    let(:request_limit) { (1..10000).to_a.sample }
-    let(:request_count) { (1..(request_limit-10)).to_a.sample }
-    
-    let(:rack_attack_throttle_data) do
-      { "#{throttle}" => { count: request_count, limit: request_limit } }
-    end
-    
     before(:each) do
-      get "/", {}, { "#{Rack::Attack::RateLimit::RACK_ATTACK_KEY}" => rack_attack_throttle_data } 
+      get '/', {}, "#{Rack::Attack::RateLimit::RACK_ATTACK_KEY}" => rack_attack_throttle_data
     end
-    
-    it 'should include RateLimit headers' do
-      last_response.header.key?('X-RateLimit-Limit').should be true
-      last_response.header.key?('X-RateLimit-Remaining').should be true
-    end
-    
-    it 'should return correct rate limit in header' do
-      last_response.header['X-RateLimit-Limit'].to_i.should eq request_limit
+
+    let(:request_limit) { (1..10_000).to_a.sample }
+    let(:request_count) { (1..(request_limit - 10)).to_a.sample }
+
+    context 'one throttle only' do
+
+      let(:rack_attack_throttle_data) do
+        { "#{throttle_one}" => { count: request_count, limit: request_limit } }
+      end
+
+      it 'should include RateLimit headers' do
+        last_response.header.key?('X-RateLimit-Limit').should be true
+        last_response.header.key?('X-RateLimit-Remaining').should be true
+      end
+
+      it 'should return correct rate limit in header' do
+        last_response.header['X-RateLimit-Limit'].to_i.should eq request_limit
+      end
+
+      it 'should return correct remaining calls in header' do
+        last_response.header['X-RateLimit-Remaining'].to_i.should eq(request_limit - request_count)
+      end
     end
-    
-    it 'should return correct remaining calls in header' do
-      last_response.header['X-RateLimit-Remaining'].to_i.should eq (request_limit-request_count)
+
+    context 'multiple throttles' do
+
+      let(:app) do
+        use_throttle = [throttle_one, throttle_two, throttle_three]
+        Rack::Builder.new do
+          use Rack::Attack::RateLimit, throttle: use_throttle
+          run ->(_env) { [200, {}, 'Hello, World!'] }
+        end.to_app
+      end
+
+      let(:request_limits) { 3.times.map { (1..10_000).to_a.sample } }
+      let(:request_counts) { 3.times.map { |index| (1..(request_limits[index] - 10)).to_a.sample } }
+
+      let(:rack_attack_throttle_data) do
+        data = {}
+        [throttle_one, throttle_two, throttle_three].each_with_index do |thr, thr_index|
+          data["#{thr}"] = { count: request_counts[thr_index], limit: request_limits[thr_index] }
+        end
+        data
+      end
+      it 'should include RateLimit headers' do
+        last_response.header.key?('X-RateLimit-Limit').should be true
+        last_response.header.key?('X-RateLimit-Remaining').should be true
+      end
+
+      describe 'header values' do
+        let(:request_differences) do
+          request_limits.map.each_with_index { |limit, index| limit - request_counts[index] }
+        end
+        let(:min_index) { request_differences.each_with_index.min.last }
+
+        it 'should return correct rate limit' do
+          last_response.header['X-RateLimit-Limit'].to_i.should eq request_limits[min_index]
+        end
+
+        it 'should return correct remaining calls' do
+          last_response.header['X-RateLimit-Remaining'].to_i.should eq(request_differences[min_index])
+        end
+      end
     end
   end
-
-end
+end

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@ require 'rack/attack/rate-limit'
 
 RSpec::configure do |config|
 
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.formatter = :documentation
   config.tty = true
+  config.color = true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-attack-rate-limit
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Jason Byck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-23 00:00:00.000000000 Z
+date: 2014-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack