sinatra-rate-limiter 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 006ef1d8689384395b156b7c636c4745287d07f0
-  data.tar.gz: 127f8f5d68dcd6898e8d21e6ac0fdfbaf16858b3
+  metadata.gz: 8adddf799a15960cccfb10260b144cd2b44f648d
+  data.tar.gz: 39755bb89f40a13226ca738c64f12c4f9c6b5493
 SHA512:
-  metadata.gz: 4360d48ffd69e8274b6e2e504547ce58847fa98ba153aedaf7c9e959c4690ac87a01131b006aa023d9b5f0485c2e609cb200d4e6031b5ba7b52c208bef9907ab
-  data.tar.gz: 20133bd94e537603a00de43971cd840a46d3212d8a046b115a0177801df7ff28299391c126cebafb550849088996fb0ded7ad25af552535c2c758e0ceaae902b
+  metadata.gz: fa29b11d746463878859cf05f2a4061a9ae09b9748a5b0cbf79e94fd60c285314a840c2bb680f2de5da1cae1180188ed863e48a5b42ac332bca7a0edb07dc33d
+  data.tar.gz: df6410fd0b9c87ac9ffff38ec7670f0db34e58d44b9501447384cc19e93f7b6dff9226c4da6659feb9ad939ef514d80936ac37407f96818e0a03071ba7eb1f30

data/README.md

@@ -79,6 +79,7 @@ you must specify limits with each call of `rate_limit`
      error_code:     429,
      error_template: nil,
      send_headers:   true,
+     header_prefix:  'Rate-Limit',
      identifier:     Proc.new{ |request| request.ip }
    }
    ```
@@ -129,10 +130,28 @@ provided (all Integers):
 
 ##### `send_headers` (Boolean)
 
-Whether or not to send `X-RateLimit-` headers to the client with each
+Whether or not to send `Rate-Limit-*` headers to the client with each
 request. A `Retry-After` header is currently always sent when a rate
 limit is reached regardless of this setting.
 
+Three headers are sent per defined limit:
+
+ * `Rate-Limit-Limit` the number of requests allowed per period
+ * `Rate-Limit-Remaining` the number of requests left in the current period
+ * `Rate-Limit-Reset` the number of seconds remaining until the limit resets
+
+If a bucket name is defined, it will be included in the header in the format
+`Rate-Limit-Bucketname-*`. If more than one limit is defined, a number will
+also be added to differentiate them, e.g `Rate-Limit-1-*`, `Rate-Limit-2-*`,
+`Rate-Limit-Bucketname-1-*`, etc.
+
+##### `header_prefix` (String)
+
+Prefix for HTTP headers sent to client. Default is `Rate-Limit` (per 
+[RFC 6648](https://tools.ietf.org/html/rfc6648) deprecating the `X-` prefix)
+however some users may wish or need to send `X-Rate-Limit` or some other
+arbitrary header prefix instead.
+
 ##### `identifier` (Proc)
 
 A `Proc` taking exactly one parameter (`request`) which returns a String

data/lib/sinatra/rate-limiter.rb

@@ -17,17 +17,18 @@ module Sinatra
         limiter.request   = request
         limiter.options   = options
 
-        if error_locals = limits_exceeded?(limits, limiter)
-          rate_limit_headers(limits, bucket, limiter) if limiter.options.send_headers
+        if error_locals = limiter.limits_exceeded?
+          limiter.rate_limit_headers.each{|h,v| response.headers[h] = v} if limiter.options.send_headers
+
           response.headers['Retry-After'] = error_locals[:try_again]
-          halt limiter.options.error_code, error_response(error_locals, limiter)
+          halt limiter.options.error_code, error_response(limiter, error_locals)
         end
 
-        redis(limiter).setex([namespace(limiter),user_identifier(limiter),bucket,Time.now.to_f.to_s].join('/'),
+        redis.setex([namespace,limiter.user_identifier,bucket,Time.now.to_f.to_s].join('/'),
                              settings.rate_limiter_redis_expires,
                              request.env['REQUEST_URI'])
 
-        rate_limit_headers(limits, bucket, limiter) if limiter.options.send_headers
+        limiter.rate_limit_headers.each{|h,v| response.headers[h] = v} if limiter.options.send_headers
       end
 
       private
@@ -54,43 +55,22 @@ module Sinatra
                 limits.each_slice(2).map{|a| {requests: a[0], seconds: a[1]}}]
       end
 
-      def redis(limiter)
+      def redis
         settings.rate_limiter_redis_conn
       end
 
-      def namespace(limiter)
+      def namespace
         settings.rate_limiter_redis_namespace
       end
 
-      def limit_remaining(limit, limiter)
-        limit[:requests] - limiter.history(limit[:seconds]).length
-      end
-
-      def limit_reset(limit, limiter)
-        limit[:seconds] - (Time.now.to_f - limiter.history(limit[:seconds]).first.to_f).to_i
-      end
-
-      def limits_exceeded?(limits, limiter)
-        exceeded = limits.select {|limit| limit_remaining(limit, limiter) < 1}.sort_by{|e| e[:seconds]}.last
-
-        if exceeded
-          try_again = limit_reset(exceeded, limiter)
-          return exceeded.merge({try_again: try_again.to_i})
-        end
-      end
+      def get_min_time_prefix(limits)
+        now    = Time.now.to_f
+        oldest = Time.now.to_f - limits.sort_by{|l| -l[:seconds]}.first[:seconds]
 
-      def rate_limit_headers(limits, bucket, limiter)
-        header_prefix = 'X-Rate-Limit' + (bucket.eql?('default') ? '' : '-' + bucket)
-        limit_no = 0 if limits.length > 1
-        limits.each do |limit|
-          limit_no = limit_no + 1 if limit_no
-          response.headers[header_prefix + (limit_no ? "-#{limit_no}" : '') + '-Limit']     = limit[:requests]
-          response.headers[header_prefix + (limit_no ? "-#{limit_no}" : '') + '-Remaining'] = limit_remaining(limit, limiter)
-          response.headers[header_prefix + (limit_no ? "-#{limit_no}" : '') + '-Reset']     = limit_reset(limit, limiter)
-        end
+        return now.to_s[0..((now/oldest).to_s.split(/^1\.|[1-9]+/)[1].length)].to_i.to_s
       end
 
-      def error_response(locals, limiter)
+      def error_response(limiter, locals)
         if limiter.options.error_template
           render limiter.options.error_template, locals: locals
         else
@@ -99,20 +79,6 @@ module Sinatra
         end
       end
 
-      def user_identifier(limiter)
-        if limiter.options.identifier.class == Proc
-          return limiter.options.identifier.call(request)
-        else
-          return request.ip
-        end
-      end
-
-      def get_min_time_prefix(limits)
-        now    = Time.now.to_f
-        oldest = Time.now.to_f - limits.sort_by{|l| -l[:seconds]}.first[:seconds]
-
-        return now.to_s[0..((now/oldest).to_s.split(/^1\.|[1-9]+/)[1].length)].to_i.to_s
-      end
 
     end
 
@@ -122,23 +88,22 @@ module Sinatra
       app.set :rate_limiter,                  false
       app.set :rate_limiter_environments,     [:production]
       app.set :rate_limiter_default_limits,   [10, 20]  # 10 requests per 20 seconds
-      app.set :rate_limiter_redis_conn,       Redis.new
-      app.set :rate_limiter_redis_namespace,  'rate_limit'
-      app.set :rate_limiter_redis_expires,    24*60*60 # This must be larger than longest limit time period
-
       app.set :rate_limiter_default_options, {
         error_code:     429,
         error_template: nil,
         send_headers:   true,
+        header_prefix:  'Rate-Limit',
         identifier:     Proc.new{ |request| request.ip }
       }
+
+      app.set :rate_limiter_redis_conn,       Redis.new
+      app.set :rate_limiter_redis_namespace,  'rate_limit'
+      app.set :rate_limiter_redis_expires,    24*60*60 # This must be larger than longest limit time period
     end
 
   end
 
   class RateLimit
-    attr_reader :history, :options
-
     def initialize(bucket, limits)
       @bucket        = bucket
       @limits        = limits
@@ -155,14 +120,63 @@ module Sinatra
       if @history
         @history
       else
-        @history = redis(self).
-          keys("#{[namespace(self),user_identifier(self),@bucket].join('/')}/#{@time_prefix}*").
+        @history = redis.
+          keys("#{[namespace,user_identifier,@bucket].join('/')}/#{@time_prefix}*").
           map{|k| k.split('/')[3].to_f}
       end
     end
 
+    def user_identifier
+      if options.identifier.class == Proc
+        return options.identifier.call(request)
+      else
+        return request.ip
+      end
+    end
+
+    def rate_limit_headers
+      headers = []
+
+      header_prefix = options.header_prefix + (@bucket.eql?('default') ? '' : '-' + @bucket)
+      limit_no = 0 if @limits.length > 1
+      @limits.each do |limit|
+        limit_no = limit_no + 1 if limit_no
+        headers << [header_prefix + (limit_no ? "-#{limit_no}" : '') + '-Limit',     limit[:requests]]
+        headers << [header_prefix + (limit_no ? "-#{limit_no}" : '') + '-Remaining', limit_remaining(limit)]
+        headers << [header_prefix + (limit_no ? "-#{limit_no}" : '') + '-Reset',     limit_reset(limit)]
+      end
+
+      return headers
+    end
+
+    def limit_remaining(limit)
+      limit[:requests] - history(limit[:seconds]).length
+    end
+
+    def limit_reset(limit)
+      limit[:seconds] - (Time.now.to_f - history(limit[:seconds]).first.to_f).to_i
+    end
+
+    def limits_exceeded?
+      exceeded = @limits.select {|limit| limit_remaining(limit) < 1}.sort_by{|e| e[:seconds]}.last
+
+      if exceeded
+        try_again = limit_reset(exceeded)
+        return exceeded.merge({try_again: try_again.to_i})
+      end
+    end
+
+    def redis
+      settings.rate_limiter_redis_conn
+    end
+
+    def namespace
+      settings.rate_limiter_redis_namespace
+    end
+
     def options=(options)
-      @options = OpenStruct.new(settings.rate_limiter_default_options.merge(options))
+      options = settings.rate_limiter_default_options.merge(options)
+      @options = Struct.new(*options.keys).new(*options.values)
     end
     def options
       @options

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-rate-limiter
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Warren Guy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-30 00:00:00.000000000 Z
+date: 2015-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra