redis-gcra 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b80231f7f7cb343c629c565c27cf7b6d83cdef4
+  data.tar.gz: cdcce949d903b7da612eb466baf683fbb4479bf7
+SHA512:
+  metadata.gz: 275086f4ec7c050d699f61c35451cb01725adfc084de2bf813de97ae1df930a2dc39fb05ba137a4c34aca2197696e728636d38dee77e800f539f565a5779eda9
+  data.tar.gz: 33ed550d170ccb96ba70ff1d05a3add5655ec06fa2b3ba946444c2832f1470148d11b0208d4beb89a84dbaa57ca237fa0e63c77a3202694c6f23d8e04b860d83

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Pavel Pravosud
+
+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,53 @@
+# RedisGCRA
+[![Build Status](https://travis-ci.org/rwz/redis-gcra.svg?branch=master)](https://travis-ci.org/rwz/redis-gcra)
+
+This gem is an implementation of GCRA for rate limiting based on Redis. The
+code requires Redis version 3.2+ or newer since it relies on
+[`replicate_comands`][redis-replicate-commands] feature.
+
+[redis-replicate-commands]: https://redis.io/commands/eval#replicating-commands-instead-of-scripts
+## Installation
+
+```ruby
+gem "redis-gcra"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis-gcra
+
+## Usage
+
+```ruby
+redis = Redis.new
+
+result = RedisGCRA.limit(
+  redis: redis,
+  key: "rate-limit-key",
+  burst: 1000,
+  rate: 100,
+  period: 60,
+  cost: 2
+)
+
+result.limited?    # => false - request should not be limited
+result.remaning    # => 998   - remaining number of requests until limited
+result.retry_after # => nil   - can retry without delay
+result.reset_after # => ~0.6  - in 0.6s rate limiter will completely reset
+
+# do this 500 more times and then
+
+result.limited?    # => true - request should be limited
+result.remaining   # => 0    - no requests can be made at this point
+result.retry_after # => ~1.1 - can retry in 1.1seconds
+result.reset_after # => ~600 - in 600s rate limiter will completely reset
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/redis-gcra.rb

@@ -0,0 +1,49 @@
+require "thread"
+
+module RedisGCRA
+  extend self
+
+  autoload :Result, "redis-gcra/result"
+
+  def limit(redis:, key:, burst:, rate:, period:, cost: 1)
+    resp = call_script(
+      redis,
+      :perform_gcra_ratelimit,
+      keys: [key],
+      argv: [burst, rate, period, cost]
+    )
+
+    Result.new(
+      limited: resp[0] == 1,
+      remaining: resp[1],
+      retry_after: resp[2] == "-1" ? nil : resp[2].to_f,
+      reset_after: resp[3].to_f
+    )
+  end
+
+  private
+
+  def call_script(redis, script_name, *args)
+    script_sha = mutex.synchronize { get_cached_sha(redis, script_name) }
+    redis.evalsha script_sha, *args
+  end
+
+  def redis_cache
+    @redis_script_cache ||= {}
+  end
+
+  def mutex
+    @mutex ||= Mutex.new
+  end
+
+  def get_cached_sha(redis, script_name)
+    sha = redis_cache.dig(redis.id, script_name)
+    return sha if sha
+
+    script = File.read(File.expand_path("../../vendor/#{script_name}.lua", __FILE__))
+    sha = redis.script(:load, script)
+    redis_cache[redis.id] ||= {}
+    redis_cache[redis.id][script_name] = sha
+    sha
+  end
+end

data/lib/redis-gcra/result.rb

@@ -0,0 +1,16 @@
+module RedisGCRA
+  class Result
+    attr_reader :remaining, :reset_after, :retry_after
+
+    def initialize(limited:, remaining:, reset_after:, retry_after:)
+      @limited = limited
+      @remaining = remaining
+      @reset_after = reset_after
+      @retry_after = retry_after
+    end
+
+    def limited?
+      !!@limited
+    end
+  end
+end

data/lib/redis-gcra/version.rb

@@ -0,0 +1,3 @@
+module RedisGCRA
+  VERSION = "0.1.0".freeze
+end

data/vendor/perform_gcra_ratelimit.lua

@@ -0,0 +1,53 @@
+-- this script has side-effects, so it requires replicate commands mode
+redis.replicate_commands()
+
+local rate_limit_key = KEYS[1]
+local burst = ARGV[1]
+local rate = ARGV[2]
+local period = ARGV[3]
+local cost = ARGV[4]
+
+local emission_interval = period / rate
+local increment = emission_interval * cost
+local burst_offset = emission_interval * burst
+local now = redis.call("TIME")
+
+-- redis returns time as an array containing two integers: seconds of the epoch
+-- time and microseconds. for convenience we need to convert them to float
+-- point number
+now = now[1] + now[2] / 1000000
+
+local tat = redis.call("GET", rate_limit_key)
+
+if not tat then
+  tat = now
+else
+  tat = tonumber(tat)
+end
+
+local new_tat = math.max(tat, now) + increment
+
+local allow_at = new_tat - burst_offset
+local diff = now - allow_at
+
+local limited
+local remaining
+local retry_after
+local reset_after
+
+if diff < 0 then
+  limited = 1
+  remaining = 0
+  reset_after = tat - now
+  retry_after = diff * -1
+else
+  local ttl = new_tat - now
+  redis.call("SET", rate_limit_key, new_tat, "EX", math.ceil(ttl))
+  local next_in = burst_offset - ttl
+  remaining = math.floor(next_in / emission_interval)
+  reset_after = ttl
+  retry_after = -1
+  limited = 0
+end
+
+return {limited, remaining, tostring(retry_after), tostring(reset_after)}

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: redis-gcra
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pavel Pravosud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: 
+email:
+- pavel@pravosud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/redis-gcra.rb
+- lib/redis-gcra/result.rb
+- lib/redis-gcra/version.rb
+- vendor/perform_gcra_ratelimit.lua
+homepage: https://github.com/rwz/redis-gcra
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Rate limiting based on Generic Cell Rate Algorithm
+test_files: []