Class: Rack::Throttle::Limiter

Inherits:
Object
  • Object
show all
Defined in:
lib/rack/throttle/limiters/limiter.rb

Overview

This is the base class for rate limiter implementations.

Examples:

Defining a rate limiter subclass

class MyLimiter < Limiter
  def allowed?(request)
    # TODO: custom logic goes here
  end
end

Direct Known Subclasses

Interval, SlidingWindow, TimeWindow

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app, options = {}) ⇒ Limiter

Returns a new instance of Limiter.

Parameters:

  • app (#call)
  • options (Hash{Symbol => Object}) (defaults to: {})

Options Hash (options):

  • :cache (String) — default: Hash.new
  • :key (String) — default: nil
  • :key_prefix (String) — default: nil
  • :code (Integer) — default: 403
  • :message (String) — default: "Rate Limit Exceeded" 


23
24
25
26
27
28
29
30
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 23

def initialize(app, options = {})
  rules = options.delete(:rules) || {}
  @app, @options, @matchers = app, options, []
  @matchers += Array(rules[:url]).map { |rule| UrlMatcher.new(rule) } if rules[:url]
  @matchers += Array(rules[:user_agent]).map { |rule| UserAgentMatcher.new(rule) } if rules[:user_agent]
  @matchers += Array(rules[:method]).map { |rule| MethodMatcher.new(rule) } if rules[:method]
  @matchers += Array(rules[:basic_auth]).map { |rule| BasicAuthMatcher.new(rule) } if rules[:basic_auth]
end

Instance Attribute Details

#app ⇒ Object (readonly)

Returns the value of attribute app.



13
14
15
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 13

def app
  @app
end

#matchers ⇒ Object (readonly)

Returns the value of attribute matchers.



13
14
15
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 13

def matchers
  @matchers
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



13
14
15
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 13

def options
  @options
end

Instance Method Details

#allowed?(request) ⇒ Boolean

Returns ‘false` if the rate limit has been exceeded for the given `request`, or `true` otherwise.

Override this method in subclasses that implement custom rate limiter strategies.

Parameters:

  • request (Rack::Request)

Returns:

  • (Boolean) 


68
69
70
71
72
73
74
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 68

def allowed?(request)
  case
    when whitelisted?(request) then true
    when blacklisted?(request) then false
    else true # override in subclasses
  end
end

#blacklisted?(request) ⇒ Boolean

This method is abstract.

Returns ‘true` if the originator of the given `request` is blacklisted (not honoring rate limits, and thus permanently forbidden access without the need to maintain further rate limit counters).

The default implementation always returns ‘false`. Override this method in a subclass to implement custom blacklisting logic.

Parameters:

  • request (Rack::Request)

Returns:

  • (Boolean) 


101
102
103
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 101

def blacklisted?(request)
  false
end

#call(env) ⇒ Array(Integer, Hash, #each)

Parameters:

  • env (Hash{String => String})

Returns:

  • (Array(Integer, Hash, #each))

See Also:



36
37
38
39
40
41
42
43
44
45
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 36

def call(env)
  request = Rack::Request.new(env)
  match_results = @matchers.map { |m| m.match?(request) }.uniq
  applicable = @matchers.empty? || match_results == [true]
  if applicable and !allowed?(request)
    rate_limit_exceeded
  else
    app.call(env)
  end
end

#restricted_url?(path) ⇒ Boolean

Returns ‘true` if no :url_rule regex or if the request path matches the :url regex, `false` otherwise.

You can override this class, though that might be weird.

Parameters:

  • path (String)

Returns:

  • (Boolean) 


55
56
57
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 55

def restricted_url?(path)
  options[:url_rule].nil? || options[:url_rule].match(path)
end

#whitelisted?(request) ⇒ Boolean

This method is abstract.

Returns ‘true` if the originator of the given `request` is whitelisted (not subject to further rate limits).

The default implementation always returns ‘false`. Override this method in a subclass to implement custom whitelisting logic.

Parameters:

  • request (Rack::Request)

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/rack/throttle/limiters/limiter.rb', line 86

def whitelisted?(request)
  false
end