praroter 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a107a6850338e77ecac23ff79c3ec477fbdf6615cb6b58a705e2f575752d2493
+  data.tar.gz: 595c3f911778b4fd1a8a6dd64da6e8c7b0185db0c3ca6fc34bfc3b6b4926f719
+SHA512:
+  metadata.gz: 6bb75c4e204bb148c9f7928689c3bf7c0d5c8fb356820a34a6a0160fd7f97606914ae73b561fa9ec3bdb5d1862028ce778e01e5e8145e5f7d7bd1f9eb1d11f72
+  data.tar.gz: 99192564d7291ede39f07d5d7ee8c0f8c780c37f3faa45726ab141f8987445d5fa8b6c1eeb346cddb29de5e13e6bd241151d5080e26d3135a8a78a1e2f83a463

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_gem:
+  wetransfer_style: ruby/default.yml

data/.travis.yml

@@ -0,0 +1,17 @@
+rvm:
+- 2.2
+- 2.3
+- 2.4
+- 2.5
+- 2.6
+- 2.7
+
+services:
+- redis
+
+dist: trusty # https://docs.travis-ci.com/user/trusty-ci-environment/
+sudo: false
+cache: bundler
+
+script:
+  - bundle exec rake

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Julik Tarkhanov
+
+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,198 @@
+# Praroter
+
+This is built on top of, and forked from the excellent gem named Prorate by WeTransfer: https://github.com/WeTransfer/prorate
+
+It was forked because we had slightly different needs for our endpoints:
+
+- We bill calls based on how long the request takes (Prorate is built to bill per requests)
+- We only know how long the request took by the end of the request cycle so we have to bill after the work is done (Prorate bills in the beginning of the request)
+- Because we bill by the end of the request, we allow consumers to "owe" us time, that they have to pay back by waiting longer.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'praroter'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install praroter
+```
+
+## Implementation
+
+The simplest mode of operation is throttling an endpoint, this is done by:
+
+- 1. First check if the bucket is empty
+- 2. Then do work
+- 3. Drain the amount of work done from bucket
+
+## Naïve Rails implementation
+
+Within your Rails controller:
+
+```ruby
+def index
+  # 1. First check if the bucket is empty
+  # -----------------------------------------------------------
+  redis = Redis.new
+  rate_limiter = Praroter::FillyBucket::Creator.new(redis: redis)
+  bucket = rate_limiter.setup_bucket(
+    key: [request.ip, params.require(:email)].join,
+    fill_rate: 2, # per second
+    capacity: 20 # default, acts as a buffer
+  )
+  bucket.throttle! # This will throw Prarotor::Throttled if level is negative
+  request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+  # 2. Then do work
+  # -----------------------------------------------------------
+  sleep(2.242)
+
+  # 3. Drain the amount of work from bucket
+  # -----------------------------------------------------------
+  request_end = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  request_diff = ((request_end - request_start) * 1000).to_i
+  bucket.drain(request_diff)
+
+  render plain: "Home"
+end
+```
+
+To capture that exception, add this to the controller:
+
+```ruby
+rescue_from Praroter::Throttled do |e|
+  response.set_header('X-Ratelimit-Level', e.bucket_state.level)
+  response.set_header('X-Ratelimit-Capacity', e.bucket_state.capacity)
+  response.set_header('X-Ratelimit-Retry-After', e.retry_in_seconds)
+  render nothing: true, status: 429
+end
+```
+
+## Prettier Rails implementation
+
+Within your initializers:
+
+```ruby
+require 'prarotor'
+
+redis = Redis.new
+Rails.configuration.rate_limiter = Praroter::FillyBucket::Creator.new(redis: redis)
+```
+
+Within your Rails controller:
+
+```ruby
+def index
+  # 1. First check if the bucket is empty
+  # -----------------------------------------------------------
+  ratelimit_bucket.throttle!
+
+  # 3. Drain the amount of work from bucket
+  # -----------------------------------------------------------
+  ratelimit_bucket.drain_block do
+    # 2. Then do work
+    # ---------------------------------------------------------
+    sleep(2.242)
+  end
+end
+
+protected
+
+def ratelimit_bucket
+  @ratelimit_bucket ||= Rails.configuration.rate_limiter.setup_bucket(
+    key: [request.ip, params.require(:email)].join,
+    fill_rate: 2, # per second
+    capacity: 20 # default, acts as a buffer
+  )
+end
+```
+
+## Perfect Rails implementation
+
+Within your initializers:
+
+```ruby
+require 'prarotor'
+
+redis = Redis.new
+Rails.configuration.rate_limiter = Praroter::FillyBucket::Creator.new(redis: redis)
+```
+
+Within your Rails controller:
+
+```ruby
+around_action :api_ratelimit
+
+def index
+  # 2. Then do work
+  # ---------------------------------------------------------
+  sleep(2.242)
+end
+
+rescue_from Praroter::FillyBucket::Throttled do |e|
+  response.set_header('X-Ratelimit-Level', e.bucket_state.level)
+  response.set_header('X-Ratelimit-Capacity', e.bucket_state.capacity)
+  response.set_header('X-Ratelimit-Retry-After', e.retry_in_seconds)
+  render nothing: true, status: 429
+end
+
+protected
+
+def api_ratelimit
+  # 1. First check if the bucket is empty
+  # -----------------------------------------------------------
+  ratelimit_bucket.throttle!
+
+  # 3. Drain the amount of work from bucket
+  # -----------------------------------------------------------
+  bucket_state = ratelimit_bucket.drain_block do
+    yield
+  end
+  response.set_header('X-Ratelimit-Level', bucket_state.level)
+  response.set_header('X-Ratelimit-Capacity', bucket_state.capacity)
+end
+
+def ratelimit_bucket
+  @ratelimit_bucket ||= Rails.configuration.rate_limiter.setup_bucket(
+    key: [request.ip, params.require(:email)].join,
+    fill_rate: 2, # per second
+    capacity: 20 # default, acts as a buffer
+  )
+end
+```
+
+## Why Lua?
+
+Praroter is a fork of Prorate, here's what they are saying about the choice of Lua:
+
+Prorate is implementing throttling using the "Leaky Bucket" algorithm and is extensively described [here](https://github.com/WeTransfer/prorate/blob/master/lib/prorate/throttle.rb). The implementation is using a Lua script, because is the only language available which runs _inside_ Redis. Thanks to the speed benefits of Lua the script runs fast enough to apply it on every throttle call.
+
+Using a Lua script in Prorate helps us achieve the following guarantees:
+
+- **The script will run atomically.** The script is evaluated as a single Redis command. This ensures that the commands in the Lua script will never be interleaved with another client: they will always execute together.
+- **Any usages of time will use the Redis time.** Throttling requires a consistent and monotonic _time source_. The only monotonic and consistent time source which is usable in the context of Prorate, is the `TIME` result of Redis itself. We are throttling requests from different machines, which will invariably have clock drift between them. This way using the Redis server `TIME` helps achieve consistency.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kaspergrubbe/praroter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'rubocop/rake_task'
+require 'yard'
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  # The dash has to be between the two to "divide" the source files and
+  # miscellaneous documentation files that contain no code
+  t.files = ['lib/**/*.rb', '-', 'LICENSE.txt', 'CHANGELOG.md']
+end
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = ["-c", "--order=rand"]
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RuboCop::RakeTask.new(:rubocop)
+task default: [:spec, :rubocop]

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "praroter"
+
+require 'connection_pool'
+@redis_pool = ConnectionPool.new(size: 5, timeout: 5) do
+  Redis.new(
+    id: "Praroter-#{Thread.current.object_id}-PID-#{Process.pid}",
+    tcp_keepalive: 30,
+    reconnect_attempts: 1
+  )
+end
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/docker-compose.yml

@@ -0,0 +1,7 @@
+version: "3.8"
+
+services:
+  redis:
+    image: redis:6.0.9-alpine
+    ports:
+      - "6379:6379"

data/lib/praroter.rb

@@ -0,0 +1,8 @@
+require "praroter/version"
+require "redis"
+
+module Praroter
+  Dir.glob(__dir__ + '/praroter/**/*.rb').sort.each do |path|
+    require path
+  end
+end

data/lib/praroter/filly_bucket.lua

@@ -0,0 +1,57 @@
+-- this is required to be able to use TIME and writes; basically it lifts the script into IO
+redis.replicate_commands()
+
+-- Redis documentation recommends passing the keys separately so that Redis
+-- can - in the future - verify that they live on the same shard of a cluster, and
+-- raise an error if they are not. As far as can be understood this functionality is not
+-- yet present, but if we can make a little effort to make ourselves more future proof
+-- we should.
+local bucket_level_key = KEYS[1]
+local last_updated_key = KEYS[2]
+
+local bucket_capacity = tonumber(ARGV[1]) -- How many tokens is the bucket allowed to contain
+local fill_rate = tonumber(ARGV[2])
+local scoop = tonumber(ARGV[3]) -- How many tokens to remove
+
+-- Take a timestamp
+local redis_time = redis.call("TIME") -- Array of [seconds, microseconds]
+local now = tonumber(redis_time[1]) + (tonumber(redis_time[2]) / 1000000)
+
+-- get current bucket level. The throttle key might not exist yet in which
+-- case we default to bucket_capacity
+local bucket_level = tonumber(redis.call("GET", bucket_level_key)) or bucket_capacity
+
+-- ...and then perform the leaky bucket fillup/leak. We need to do this also when the bucket has
+-- just been created because the initial fillup to add might be so high that it will
+-- immediately overflow the bucket and trigger the throttle, on the first call.
+local last_updated = tonumber(redis.call("GET", last_updated_key)) or now -- use sensible default of 'now' if the key does not exist
+
+-- Add the number of tokens dripped since last call
+local dt = now - last_updated
+local new_bucket_level = bucket_level + (fill_rate * dt) - scoop
+
+-- and _then_ and add the tokens we fillup with
+new_bucket_level = math.min(bucket_capacity, new_bucket_level)
+
+-- Compute the key TTL for the bucket. We are interested in how long it takes the bucket
+-- to leak all the way to bucket_capacity, as this is the time when the values stay relevant. We pad with 1 second
+-- to have a little cushion.
+local key_lifetime = nil
+if new_bucket_level < 0 then -- if new_bucket_level is negative, then the TTL need to be longer
+  key_lifetime = math.ceil((math.abs(bucket_capacity - new_bucket_level) / fill_rate) + 1)
+else
+  key_lifetime = math.ceil((bucket_capacity / fill_rate) + 1)
+end
+
+if new_bucket_level == bucket_capacity then
+  return {new_bucket_level, bucket_capacity, fill_rate}
+else
+  -- Save the new bucket level
+  redis.call("SETEX", bucket_level_key, key_lifetime, new_bucket_level)
+
+  -- Record when we updated the bucket so that the amount of tokens leaked
+  -- can be correctly determined on the next invocation
+  redis.call("SETEX", last_updated_key, key_lifetime, now)
+
+  return {new_bucket_level, bucket_capacity, fill_rate}
+end

data/lib/praroter/filly_bucket.rb

@@ -0,0 +1,107 @@
+module Praroter
+
+  module FillyBucket
+
+    class BucketState < Struct.new(:level, :capacity, :fill_rate)
+      def empty?
+        level <= 0
+      end
+
+      def full?
+        level >= capacity
+      end
+    end
+
+    class Bucket
+      attr_reader :key, :fill_rate, :capacity
+
+      def initialize(key, fill_rate, capacity, creator)
+        @key = key
+        @fill_rate = fill_rate
+        @capacity = capacity
+        @creator = creator
+      end
+
+      def state
+        @creator.run_lua_bucket_script(self, 0)
+      end
+
+      def empty?
+        state.empty?
+      end
+
+      def full?
+        state.full?
+      end
+
+      def throttle!
+        bucket_state = state
+        if bucket_state.empty?
+          remaining_block_time = ((bucket_state.capacity - bucket_state.level).abs / bucket_state.fill_rate) + 3
+          raise Praroter::Throttled.new(bucket_state, remaining_block_time)
+        end
+        bucket_state
+      end
+
+      def drain(amount)
+        raise ArgumentError, "drain amount must be positive" if amount < 0
+        @creator.run_lua_bucket_script(self, amount)
+      end
+
+      def drain_block
+        work_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        work_end = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        drain(((work_end - work_start) * 1000).to_i)
+      end
+
+      def level_key
+        "filly_bucket.#{key}.bucket_level"
+      end
+
+      def last_updated_key
+        "filly_bucket.#{key}.last_updated"
+      end
+    end
+
+    class Creator
+      LUA_SCRIPT_CODE = File.read(File.join(__dir__, "filly_bucket.lua"))
+      LUA_SCRIPT_HASH = Digest::SHA1.hexdigest(LUA_SCRIPT_CODE)
+
+      def initialize(redis:)
+        @redis = redis.respond_to?(:with) ? redis : NullPool.new(redis)
+      end
+
+      def setup_bucket(key:, fill_rate:, capacity:)
+        Praroter::FillyBucket::Bucket.new(key, fill_rate, capacity, self)
+      end
+
+      def run_lua_bucket_script(bucket, amount)
+        @redis.with do |r|
+          begin
+            # The script returns a tuple of "whole tokens, microtokens"
+            # to be able to smuggle the float across (similar to Redis TIME command)
+            new_bucket_level, bucket_capacity, fill_rate = r.evalsha(
+              LUA_SCRIPT_HASH,
+              keys: [bucket.level_key, bucket.last_updated_key],
+              argv: [bucket.capacity, bucket.fill_rate, amount]
+            )
+            BucketState.new(new_bucket_level, bucket_capacity, fill_rate)
+          rescue Redis::CommandError => e
+            if e.message.include? "NOSCRIPT"
+              # The Redis server has never seen this script before. Needs to run only once in the entire lifetime
+              # of the Redis server, until the script changes - in which case it will be loaded under a different SHA
+              r.script(:load, LUA_SCRIPT_CODE)
+              retry
+            else
+              raise e
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/praroter/null_logger.rb

@@ -0,0 +1,15 @@
+module Praroter
+  module NullLogger
+    def self.debug(*); end
+
+    def self.info(*); end
+
+    def self.warn(*); end
+
+    def self.error(*); end
+
+    def self.fatal(*); end
+
+    def self.unknown(*); end
+  end
+end

data/lib/praroter/null_pool.rb

@@ -0,0 +1,7 @@
+module Praroter
+  class NullPool < Struct.new(:conn)
+    def with
+      yield conn
+    end
+  end
+end

data/lib/praroter/throttled.rb

@@ -0,0 +1,17 @@
+# The Throttled exception gets raised when a throttle is triggered.
+#
+# The exception carries additional attributes which can be used for
+# error tracking and for creating a correct Retry-After HTTP header for
+# a 429 response
+class Praroter::Throttled < StandardError
+  # @attr [Integer] for how long the caller will be blocked, in seconds.
+  attr_reader :retry_in_seconds
+
+  attr_reader :bucket_state
+
+  def initialize(bucket_state, try_again_in)
+    @bucket_state = bucket_state
+    @retry_in_seconds = try_again_in
+    super("Throttled, please lower your temper and try again in #{retry_in_seconds} seconds")
+  end
+end

data/lib/praroter/version.rb

@@ -0,0 +1,3 @@
+module Praroter
+  VERSION = "1.0.0"
+end

data/praroter.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'praroter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "praroter"
+  spec.version       = Praroter::VERSION
+  spec.authors       = ["Kasper Grubbe", "Julik Tarkhanov"]
+  spec.email         = ["praroter@kaspergrubbe.com"]
+
+  spec.summary       = %q{Time-restricted rate limiter using Redis}
+  spec.description   = %q{Can be used to implement all kinds of throttles}
+  spec.homepage      = "https://github.com/kaspergrubbe/praroter"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "redis", '~> 4', '>= 4'
+  spec.add_development_dependency "connection_pool", "~> 2"
+  spec.add_development_dependency "bundler", "~> 2"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'wetransfer_style', '0.6.5'
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'pry', '~> 0.13.1'
+
+  spec.add_development_dependency 'rails', '~> 6.0.3'
+  spec.add_development_dependency 'rspec-rails', '~> 4'
+end

data/scripts/bm.rb

@@ -0,0 +1,36 @@
+# Runs a mild benchmark and prints out the average time a call to 'throttle!' takes.
+
+require 'praroter'
+require 'benchmark'
+require 'redis'
+require 'securerandom'
+
+def average_ms(ary)
+  ary.map { |x| x * 1000 }.inject(0, &:+) / ary.length
+end
+
+redis = Redis.new
+
+times = []
+50.times do
+  times << Benchmark.realtime {
+    rl = Praroter::FillyBucket::Creator.new(redis: redis)
+    b = rl.setup_bucket(key: "throttle-login-email", capacity: 60, fill_rate: 2)
+    b.throttle!
+  }
+end
+
+puts average_ms times
+
+times = []
+50.times do
+  email = SecureRandom.hex(20)
+  ip = SecureRandom.hex(10)
+  times << Benchmark.realtime {
+    rl = Praroter::FillyBucket::Creator.new(redis: redis)
+    b = rl.setup_bucket(key: "#{email}-#{ip}", capacity: 60, fill_rate: 2)
+    b.throttle!
+  }
+end
+
+puts average_ms times

data/scripts/bm_latency_lb_vs_mget.rb

@@ -0,0 +1,61 @@
+# Runs a mild benchmark and prints out the average time a call to 'throttle!' takes.
+
+require 'praroter'
+require 'benchmark'
+require 'redis'
+require 'securerandom'
+
+def average_ms(ary)
+  ary.map { |x| x * 1000 }.inject(0, &:+) / ary.length
+end
+
+redis = Redis.new
+
+script_path = File.join(__dir__, "lib", "praroter", "filly_bucket.lua").gsub("/scripts", "")
+LUA_SCRIPT_CODE = File.read(script_path)
+LUA_SCRIPT_HASH = Digest::SHA1.hexdigest(LUA_SCRIPT_CODE)
+redis_script_hash = redis.script(:load, LUA_SCRIPT_CODE)
+
+raise "LUA/REDIS SCRIPT MISMATCH" if LUA_SCRIPT_HASH != redis_script_hash
+
+times = []
+15.times do
+  times << Benchmark.realtime {
+    key = "api"
+    redis.evalsha(
+      redis_script_hash,
+      keys: ["filly_bucket.#{key}.bucket_level", "filly_bucket.#{key}.last_updated"],
+      argv: [120, 50, 10]
+    )
+  }
+end
+
+puts average_ms times
+def key_for_ts(ts)
+  "th:%s:%d" % [@id, ts]
+end
+
+times = []
+15.times do
+  sec, _ = redis.time # Use Redis time instead of the system timestamp, so that all the nodes are consistent
+  ts = sec.to_i # All Redis results are strings
+  k = key_for_ts(ts)
+  times << Benchmark.realtime {
+    redis.multi do |txn|
+      # Increment the counter
+      txn.incr(k)
+      txn.expire(k, 120)
+
+      span_start = ts - 120
+      span_end = ts + 1
+      possible_keys = (span_start..span_end).map { |prev_time| key_for_ts(prev_time) }
+
+      # Fetch all the counter values within the time window. Despite the fact that this
+      # will return thousands of elements for large sliding window sizes, the values are
+      # small and an MGET in Redis is pretty cheap, so perf should stay well within limits.
+      txn.mget(*possible_keys)
+    end
+  }
+end
+
+puts average_ms times

data/scripts/test.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+redis-cli --ldb --eval lib/praroter/filly_bucket.lua filly_bucket.api.user:42.bucket_level filly_bucket.api.user:42.last_updated , 5000 100 1000

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification
+name: praroter
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kasper Grubbe
+- Julik Tarkhanov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: wetransfer_style
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.5
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Can be used to implement all kinds of throttles
+email:
+- praroter@kaspergrubbe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docker-compose.yml
+- lib/praroter.rb
+- lib/praroter/filly_bucket.lua
+- lib/praroter/filly_bucket.rb
+- lib/praroter/null_logger.rb
+- lib/praroter/null_pool.rb
+- lib/praroter/throttled.rb
+- lib/praroter/version.rb
+- praroter.gemspec
+- scripts/bm.rb
+- scripts/bm_latency_lb_vs_mget.rb
+- scripts/test.sh
+homepage: https://github.com/kaspergrubbe/praroter
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Time-restricted rate limiter using Redis
+test_files: []