dalli-rate_limiter 0.1.2 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a4f84f2172c086af81637b00a5f9d29d6d856a2
+  data.tar.gz: f49d4308f8d54d941c4deb47a6c48995ab8f9a86
+SHA512:
+  metadata.gz: 92c0c0915aaa215d4f7968113b95f09e710a9d5fbb1da2fc6c1466930ba3e0e8eba7ad2f3ec8eb6079597929eea22bb9c276d21270e6bcfc11fe246ef7191703
+  data.tar.gz: 2e12c617f7953b982f05d3e7072919234ca4c542268c66fbe54151931f725079263e22ac84fd28cab9ca6301a76e41581dd1a383551239fb85701d291b7f2657

data/.travis.yml

@@ -11,4 +11,6 @@ rvm:
   - jruby-9.0.5.0
   - rbx-2.5.8
   - rbx-3.14
+jdk:
+  - oraclejdk8
 before_install: gem install bundler -v 1.11.2

data/README.md

@@ -21,20 +21,26 @@ tightly integrate a check within your business logic.
 [ConnectionPool][5] gems for fast and efficient Memcached access and
 thread-safe connection pooling. It uses an allowance counter and floating
 timestamp to implement a sliding window for each unique key, enforcing a limit
-of _m_ requests over a period of _n_ seconds. It supports arbitrary unit
-quantities of consumption for operations that logically count as more than one
-request (i.e. batched requests). A simple mutex locking scheme (enabled by
-default) is used to mitigate race conditions and ensure that the limit is
-enforced under most cirumstances (see [Caveats](#caveats) below).  Math
-operations are performed with three decimal places of precision but the results
-are stored in Memcached as integers.
+of _m_ requests over a period of _n_ seconds. If you're familiar with
+[Sidekiq][10] (which is another excellent piece of software, written by the same
+person who wrote Dalli and ConnectionPool), it is similar to the Window style
+of the Sidekiq::Limiter class, although the invocation syntax differs slightly
+(see [Block Form](#block-form) below for an example of the differences).
+
+It supports arbitrary unit quantities of consumption for partial operations or
+for operations that logically count as more than one request (i.e. batched
+requests). It leverages Memcached's compare-and-set method—which uses an
+opportunistic locking scheme—in combination with a back-off algorithm to
+mitigate race conditions while ensuring that limits are enforced under high
+levels of concurrency with a high degree of confidence. Math operations are
+performed with floating-point precision.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'dalli-rate_limiter', '~> 0.1.0'
+gem 'dalli-rate_limiter', '~> 0.2.0'
 ```
 
 And then execute:
@@ -51,11 +57,11 @@ Or install it yourself as:
 def do_foo
   lim = Dalli::RateLimiter.new
 
-  if lim.exceeded? "foo"
+  if lim.exceeded?
     fail "Sorry, can't foo right now. Try again later!"
   end
 
-  # ..
+  # Do foo...
 end
 ```
 
@@ -70,10 +76,9 @@ connection settings. Pass in `nil` to force the default behavior.
 
 The library itself defaults to five (5) requests per eight (8) seconds, but
 these can easily be changed with the `:max_requests` and `:period` options.
-Locking can be disabled by setting the `:locking` option to `false` (see
-[Caveats](#caveats) below). A `:key_prefix` option can be specified as well;
-note that this will be used in combination with any `:namespace` option defined
-in the Dalli::Client.
+Locking can be fine-tuned by setting the `:lock_timeout` option. A
+`:key_prefix` option can be specified as well; note that this will be used in
+combination with any `:namespace` option defined in the Dalli::Client.
 
 The **Dalli::RateLimiter** instance itself is not stateful, so it can be
 instantiated as needed (e.g. in a function definition) or in a more global
@@ -82,15 +87,15 @@ attributes so it should be safe to share between threads; in this case, you
 will definitely want to use either the default ConnectionPool or your own (as
 opposed to a single-threaded Dalli::Client instance).
 
-The main instance method, `#exceeded?` will return false if the request is free
-to proceed. If the limit has been exceeded, it will return a positive floating
-point value that represents the fractional number of seconds that the caller
-should wait until retrying the request. Assuming no other requests were process
-during that time, the retried request will be free to proceed at that point.
-When invoking this method, please be sure to pass in a key that is unique (in
-combination with the `:key_prefix` option described above) to the thing you are
-trying to limit. An optional second argument specifies the number of requests
-to "consume" from the allowance; this defaults to one (1).
+The main instance method, `#exceeded?` will return `false` if the request is
+free to proceed. If the limit has been exceeded, it will return a positive
+floating point value that represents the fractional number of seconds that the
+caller should wait until retrying the request. Assuming no other requests were
+process during that time, the retried request will be free to proceed at that
+point.  When invoking this method, please be sure to pass in a key that is
+unique (in combination with the `:key_prefix` option described above) to the
+thing you are trying to limit. An optional second argument specifies the number
+of requests to "consume" from the allowance; this defaults to one (1).
 
 Please note that if the number of requests is greater than the maximum number
 of requests, the limit will never not be exceeded. Consider a limit of 50
@@ -98,6 +103,14 @@ requests per minute: no amount of waiting would ever allow for a batch of 51
 requests! `#exceeded?` returns `-1` in this event. To help detect this edge
 case proactively, a public getter method `#max_requests` is available.
 
+An alternative block-form syntax is available using the `#without_exceeding`
+method. This method will call `sleep` on your behalf until the block can be
+executed without exceeding the limit, and then yield to the block. This is
+useful in situations where you want to avoid writing your own sleep-while loop.
+You can limit how long the method will sleep by passing in a `:wait_timeout`
+option; please note that the total wait time includes any time spent acquiring
+the lock.
+
 ## Advanced Usage
 
 ```ruby
@@ -116,7 +129,9 @@ def change_username(user_id, new_username)
     halt 422, "Sorry! Only two username changes allowed per hour."
   end
 
-  # ..
+  # Change username...
+rescue Dalli::RateLimiter::LockError
+  # Unable to acquire a lock...
 end
 
 def add_widgets(foo_id, some_widgets)
@@ -124,19 +139,50 @@ def add_widgets(foo_id, some_widgets)
     halt 400, "Too many widgets!"
   end
 
-  if time = lim2.exceeded? foo_id, some_widgets.length
+  if time = lim2.exceeded?(foo_id, some_widgets.length)
     halt 422, "Sorry! Unable to process request. " \
       "Please wait at least #{time} seconds before trying again."
   end
 
-  # ..
+  # Add widgets...
+rescue Dalli::RateLimiter::LockError
+  # Unable to acquire a lock...
 end
 ```
 
+## Block Form
+
+Rewriting the Sidekiq::Limiter.window [example][9] from its documentation:
+
+```ruby
+def perform(user_id)
+  user_throttle = Dalli::RateLimiter.new nil,
+    :key_prefix => "stripe", :max_requests => 5, :period => 1
+
+  user_throttle.without_exceeding(user_id, 1, :wait_timeout => 5) do
+    # call stripe with user's account creds
+  end
+rescue Dalli::RateLimiter::LimitError
+  # Unable to execute block before wait timeout...
+rescue Dalli::RateLimiter::LockError
+  # Unable to acquire a lock...
+end
+```
+
+You have the flexibility to set the `:key_prefix` to `nil` and pass in
+`"stripe:#{user_id}"` as the first argument to `#without_exceeding`, with same
+end results. Or, likewise, you could set `:key_prefix` to `"stripe:#{user_id}"`
+and pass in `nil` as the first argument to `#without_exceeding`. Sometimes it
+makes sense to share an instance between method calls, or indeed between
+different methods, and sometimes it doesn't. Please note that if `:key_prefix`
+and the first argument to `#exceeded?` or `#without_exceeding` are both `nil`,
+Dalli::Client will abort with an ArgumentError ("key cannot be blank").
+
 ## Compatibility
 
 **Dalli::RateLimiter** is compatible with Ruby 1.9.3 and greater and has been
-tested with frozen string literals under Ruby 2.3.0.
+tested with frozen string literals under Ruby 2.3.0. It has also been tested
+under Rubinius 2.15 and 3.14, and JRuby 1.7 (in 1.9.3 execution mode) and 9K.
 
 You might consider installing the [kgio][7] gem to [give Dalli a 10-20%
 performance boost][8].
@@ -149,15 +195,13 @@ noted that a Memcached ring can lose members or indeed its entire working set
 cases, where repeated operations absolutely, positively have to be restricted,
 should probably seek solutions elsewhere.
 
-The limiting algorithm seems to work well but it is far from battle-tested. I
-tried to use atomic operations where possible to mitigate race conditions, but
-still had to implement a locking scheme, which might slow down operations and
-lead to timeouts and exceptions if a lock can't be acquired for some reason.
-Locking can be disabled but this will increase the chances that a determined
-attacker figures out a way to defeat the limit.
-
-I will likely be revisiting the algorithm in the future, but at the moment it
-is in the unfortunate state of "good enough".
+The limiting algorithm, which was overhauled for the 0.2.0 release to greatly
+reduce the number of round-trips to Memcached, seems to work well but it is
+far from battle-tested. Simple benchmarking against a local Memcached instance
+shows zero lock timeouts with the default settings and 100 threads hitting the
+same limit concurrently. (Testing performed on a 2012 MacBook Pro with an Intel
+i7-3615QM processor and 16 GB RAM; benchmarking scripts available in the `bin`
+subdirectory of this repository.)
 
 As noted above, this is not a replacement for an application-level rate limit,
 and if your application faces the web, you should probably definitely have
@@ -166,6 +210,11 @@ something else in your stack to handle e.g. a casual DoS.
 Make sure your ConnectionPool has enough slots for these operations. I aim for
 one slot per thread plus one or two for overhead in my applications.
 
+## Documentation
+
+This README is fairly comprehensive, but additional information about the
+class and its methods is available in [YARD][11].
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run
@@ -196,3 +245,6 @@ License](http://opensource.org/licenses/MIT).
 [6]: http://memcached.org "Memcached"
 [7]: http://bogomips.org/kgio "kgio"
 [8]: https://github.com/petergoldstein/dalli/blob/master/Performance.md "Dalli Performance"
+[9]: https://github.com/mperham/sidekiq/wiki/Ent-Rate-Limiting#window "Sidekiq::Limiter.window"
+[10]: http://sidekiq.org "Sidekiq"
+[11]: http://www.rubydoc.info/github/mwpastore/dalli-rate_limiter/master/Dalli/RateLimiter "Dalli::RateLimiter on RubyDoc.info"

data/bin/bench.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dalli/rate_limiter"
+
+require "thread"
+require "thwait"
+
+NUM_THREADS = 100
+
+lim = Dalli::RateLimiter.new nil,
+  :key_prefix => "bench", :max_requests => 100_000, :period => 1
+
+mutex = Mutex.new
+error_count = 0
+
+threads = NUM_THREADS.times.map do
+  Thread.new do
+    1_000.times do
+      begin
+        lim.exceeded?
+      rescue
+        mutex.synchronize { error_count += 1 }
+      end
+    end
+  end
+end
+
+ThreadsWait.all_waits(*threads)
+
+puts "errors: #{error_count}"

data/bin/bench_block.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dalli/rate_limiter"
+
+require "thread"
+require "thwait"
+
+NUM_THREADS = 100
+
+lim = Dalli::RateLimiter.new nil,
+  :key_prefix => "bench_block", :max_requests => 100_000, :period => 1
+
+mutex = Mutex.new
+error_count = 0
+
+threads = NUM_THREADS.times.map do
+  Thread.new do
+    1_000.times do
+      begin
+        lim.without_exceeding { nil }
+      rescue
+        mutex.synchronize { error_count += 1 }
+      end
+    end
+  end
+end
+
+ThreadsWait.all_waits(*threads)
+
+puts "errors: #{error_count}"

data/lib/dalli/rate_limiter.rb

@@ -6,186 +6,181 @@ require "connection_pool"
 require "dalli/rate_limiter/version"
 
 module Dalli
-  INVALID_KEY_CHARS = [
-    0x00, 0x20,
-    0x09, 0x0a,
-    0x0d
-  ].map(&:chr).join("").freeze
-
   # Dalli::RateLimiter provides arbitrary Memcached-backed rate limiting for
   # your Ruby applications.
   #
   # @see file:README.md
   #
   # @!attribute [r] max_requests
-  #   @return [Float] the maximum number of requests in a human-friendly format
+  #   @return [Float] the maximum number of requests
   class RateLimiter
-    LOCK_TTL = 30
-    LOCK_MAX_TRIES = 6
+    LockError = Class.new RuntimeError
+    LimitError = Class.new RuntimeError
 
     DEFAULT_OPTIONS = {
       :key_prefix => "dalli-rate_limiter",
-      :max_requests => 5_000,
-      :period => 8_000,
-      :locking => true
+      :max_requests => 5,
+      :period => 8,
+      :lock_timeout => 30
     }.freeze
 
-    private_constant :DEFAULT_OPTIONS
+    attr_reader :max_requests
 
     # Create a new instance of Dalli::RateLimiter.
     #
-    # @param dalli [nil, ConnectionPool, Dalli::Client] the Dalli::Client (or
+    # @param dalli [ConnectionPool, Dalli::Client] the Dalli::Client (or
     #   ConnectionPool of Dalli::Client) to use as a backing store for this
     #   rate limiter
-    # @param options [Hash{Symbol}] configuration options for this rate limiter
+    # @param options [Hash] configuration options for this rate limiter
     #
-    # @option options [String] :key_prefix ("dalli-rate_limiter") a unique
-    #   string describing this rate limiter
+    # @option options [String, #to_s] :key_prefix ("dalli-rate_limiter") a
+    #   unique string describing this rate limiter
     # @option options [Integer, Float] :max_requests (5) maximum number of
     #   requests over the governed interval
     # @option options [Integer, Float] :period (8) number of seconds over
     #    which to enforce the maximum number of requests
-    # @option options [Boolean] :locking (true) enable or disable locking
+    # @option options [Integer, Float] :lock_timeout (30) maximum number of
+    #    seconds to wait for the lock to become available
     def initialize(dalli = nil, options = {})
-      @dalli = dalli || ConnectionPool.new { Dalli::Client.new }
+      @pool = dalli || ConnectionPool.new { Dalli::Client.new }
 
       options = normalize_options options
 
       @key_prefix = options[:key_prefix]
       @max_requests = options[:max_requests]
       @period = options[:period]
-      @locking = options[:locking]
-    end
-
-    def max_requests
-      to_fs @max_requests
+      @lock_timeout = options[:lock_timeout]
     end
 
     # Determine whether processing a given request would exceed the rate limit.
     #
-    # @param unique_key [String] a key to use, in combination with the
-    #   `:key_prefix` and any `:namespace` defined in the Dalli::Client, to
-    #   distinguish the item being limited from similar items
+    # @param unique_key [String, #to_s] a key to use, in combination with the
+    #   optional `:key_prefix` and any `:namespace` defined in the
+    #   Dalli::Client, to distinguish the item being limited from similar items
     # @param to_consume [Integer, Float] the number of requests to consume from
-    #   the allowance (used to represent a batch of requests)
+    #   the allowance (used to represent a partial request or a batch of
+    #   requests)
     #
     # @return [false] if the request can be processed as given without
     #   exceeding the limit (including the case where the number to consume is
     #   zero)
     # @return [Float] if processing the request as given would exceed
-    #   the limit and the caller should wait so many [fractional] seconds
+    #   the limit and the caller should wait so many (fractional) seconds
     #   before retrying
-    # @return [-1] if the number to consume exceeds the maximum,
-    #   and the request as given would never not exceed the limit
-    def exceeded?(unique_key, to_consume = 1)
-      return false if to_consume == 0
-
-      to_consume = to_ems(to_consume)
-
-      return -1 if to_consume > @max_requests
-
-      timestamp_key = format_key(unique_key, "timestamp")
-      allowance_key = format_key(unique_key, "allowance")
-
-      @dalli.with do |dc|
-        if dc.add(allowance_key, @max_requests - to_consume, @period, :raw => true)
-          # Short-circuit the simple case of seeing the key for the first time.
-          dc.set(timestamp_key, to_ems(Time.now.to_f), @period, :raw => true)
-
-          return false
-        end
-
-        lock = acquire_lock(dc, unique_key) if @locking
-
-        current_timestamp = to_ems(Time.now.to_f) # obtain timestamp after locking
-
-        previous = dc.get_multi allowance_key, timestamp_key
-        previous_allowance = previous.key?(allowance_key) ? previous[allowance_key].to_i : @max_requests
-        previous_timestamp = previous.key?(timestamp_key) ? previous[timestamp_key].to_i : current_timestamp
-
-        allowance_delta = (1.0 * (current_timestamp - previous_timestamp) * @max_requests / @period).to_i
-        projected_allowance = previous_allowance + allowance_delta
-        if projected_allowance > @max_requests
-          projected_allowance = @max_requests
-          allowance_delta = @max_requests - previous_allowance
-        end
-
-        if to_consume > projected_allowance
-          release_lock(dc, unique_key) if lock
-
-          # Tell the caller how long (in seconds) to wait before retrying the request.
-          return to_fs((1.0 * (to_consume - projected_allowance) * @period / @max_requests).to_i)
+    # @return [-1] if the number to consume exceeds the maximum, and the
+    #   request as given would never not exceed the limit
+    #
+    # @raise [LockError] if a lock cannot be obtained before `@lock_timeout`
+    def exceeded?(unique_key = nil, to_consume = 1)
+      return false if to_consume <= 0
+      return -1 if to_consume > max_requests
+
+      key = [@key_prefix, unique_key].compact.join(":")
+      to_consume = to_consume.to_f
+
+      try = 1
+      total_time = 0
+      loop do
+        @pool.with do |dc|
+          result = dc.cas(key, @period) do |previous_value|
+            wait, value = compute(previous_value, to_consume)
+            return wait if wait > 0 # caller must wait
+            value
+          end
+
+          # TODO: We can get rid of this block when Dalli::Client supports #cas!
+          if result.nil?
+            _, value = compute(nil, to_consume)
+            result = dc.add(key, value, @period)
+          end
+
+          return false if result # caller can proceed
         end
 
-        allowance_delta -= to_consume
+        time = rand * Math.sqrt(try / Math::E)
+        raise LockError, "Unable to lock key for update" \
+          if time + total_time > @lock_timeout
+        sleep time
 
-        dc.set(timestamp_key, current_timestamp, @period, :raw => true)
-        dc.add(allowance_key, previous_allowance, 0, :raw => true) # ensure baseline exists
-        dc.send(allowance_delta < 0 ? :decr : :incr, allowance_key, allowance_delta.abs)
-        dc.touch(allowance_key, @period)
-
-        release_lock(dc, unique_key) if lock
-
-        return false
+        try += 1
+        total_time += time
       end
     end
 
-    private
-
-    def normalize_options(options)
-      normalized_options = {}
+    # Execute a block without exceeding the rate limit.
+    #
+    # @param (see #exceeded?)
+    # @param options [Hash] configuration options
+    #
+    # @option options [Integer] :wait_timeout maximum number of seconds to wait
+    #   before yielding
+    #
+    # @yield block to execute within limit
+    #
+    # @raise [LimitError] if the block cannot be yielded to within
+    #  `:wait_timeout` seconds without going over the limit
+    # @raise (see #exceeded?)
+    #
+    # @return the return value of the passed block
+    def without_exceeding(unique_key = nil, to_consume = 1, options = {})
+      options[:wait_timeout] = options[:wait_timeout].to_f \
+        if options[:wait_timeout]
+
+      start_time = Time.now.to_f
+      while time = exceeded?(unique_key, to_consume)
+        raise LimitError, "Unable to yield without exceeding limit" \
+          if time < 0 || options[:wait_timeout] && time + Time.now.to_f - start_time > options[:wait_timeout]
+        sleep time
+      end
 
-      normalized_options[:key_prefix] = cleanse_key options[:key_prefix] \
-        if options[:key_prefix]
+      yield
+    end
 
-      normalized_options[:max_requests] = to_ems options[:max_requests].to_f \
-        if options[:max_requests]
+    private
 
-      normalized_options[:period] = to_ems options[:period].to_f \
-        if options[:period]
+    def compute(previous, to_consume)
+      current_timestamp = Time.now.to_f
 
-      normalized_options[:locking] = !!options[:locking] \
-        if options.key? :locking
+      previous ||= {}
+      previous_allowance = previous[:allowance] || @max_requests
+      previous_timestamp = previous[:timestamp] || current_timestamp
 
-      DEFAULT_OPTIONS.dup.merge! normalized_options
-    end
-
-    def acquire_lock(dc, key)
-      lock_key = format_key(key, "mutex")
+      allowance_delta = (current_timestamp - previous_timestamp) * @max_requests / @period
+      projected_allowance = previous_allowance + allowance_delta
+      if projected_allowance > @max_requests
+        projected_allowance = @max_requests
+        allowance_delta = @max_requests - previous_allowance
+      end
 
-      (1..LOCK_MAX_TRIES).each do |tries|
-        if lock = dc.add(lock_key, true, LOCK_TTL)
-          return lock
-        else
-          sleep rand(2**tries)
-        end
+      if to_consume > projected_allowance
+        # Determine how long the caller must wait (in seconds) before retrying the request.
+        wait = (to_consume - projected_allowance) * @period / @max_requests
+      else
+        current = {
+          :allowance => previous_allowance + allowance_delta - to_consume,
+          :timestamp => current_timestamp
+        }
       end
 
-      raise DalliError, "Unable to lock key for update"
+      [wait || 0, current || previous]
     end
 
-    def release_lock(dc, key)
-      lock_key = format_key(key, "mutex")
+    def normalize_options(options)
+      normalized_options = {}
 
-      dc.delete(lock_key)
-    end
+      normalized_options[:key_prefix] = options[:key_prefix].to_s \
+        if options.key? :key_prefix
 
-    # Convert fractional units to encoded milliunits
-    def to_ems(fs)
-      (fs * 1_000).to_i
-    end
+      normalized_options[:max_requests] = options[:max_requests].to_f \
+        if options[:max_requests] && options[:max_requests].to_f > 0
 
-    # Convert encoded milliunits to fractional units
-    def to_fs(ems)
-      1.0 * ems / 1_000
-    end
+      normalized_options[:period] = options[:period].to_f \
+        if options[:period] && options[:period].to_f > 0
 
-    def format_key(key, attribute)
-      "#{@key_prefix}:#{cleanse_key key}:#{attribute}"
-    end
+      normalized_options[:lock_timeout] = options[:lock_timeout].to_f \
+        if options[:lock_timeout] && options[:lock_timeout].to_f >= 0
 
-    def cleanse_key(key)
-      key.to_s.delete INVALID_KEY_CHARS
+      DEFAULT_OPTIONS.dup.merge! normalized_options
     end
   end
 end

data/lib/dalli/rate_limiter/version.rb

@@ -1,5 +1,5 @@
 module Dalli
   class RateLimiter
-    VERSION = "0.1.2"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,126 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: dalli-rate_limiter
 version: !ruby/object:Gem::Version
-  version: 0.1.2
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Mike Pastore
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2016-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dalli
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.7.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.7.5
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.11.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.5.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.35.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.35.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.4.0
 - !ruby/object:Gem::Dependency
   name: rspec-given
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.8.0
 description: Arbitrary Memcached-backed rate limiting for Ruby
@@ -130,14 +115,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .rubocop.yml
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/bench.rb
+- bin/bench_block.rb
 - bin/console
 - bin/setup
 - dalli-rate_limiter.gemspec
@@ -147,29 +134,25 @@ files:
 homepage: https://github.com/mwpastore/dalli-rate_limiter
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2846745512546726026
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Arbitrary Memcached-backed rate limiting for Ruby
 test_files: []