simple_throttle 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d3891997e2673589d91401b2f7c721786264c1b9
-  data.tar.gz: b4bbcffae594f108495bfe7de6de20b00038f5d8
+SHA256:
+  metadata.gz: 25cae7f3e3702407aca9ce8b20dd4a2016cdefffd9220261a0397150b10796de
+  data.tar.gz: f460f12908747e7d8d5431a7ed13274fa6eec4980a60b95949d78e553b297fb0
 SHA512:
-  metadata.gz: d2da1554c54fdd458f698c66e0a246eaf856d89e5de639f73e7a8592a820972e6a11ea90259ea6421118ed15adb043cd3cd65f40147bbb9ca7a71b87542a023b
-  data.tar.gz: b84de83b7b3dfbd61b2c60560b159e17e255cd125b58551620c5382b36cfdbfeb9df762a207493c62cea41639c3ec7ca274a61712f5d817f834464cafbed388c
+  metadata.gz: 96a6efaf9ed64b918ef077296bc1b04c36ef10f8e0e08948e505bf5203b79c4673a0435dc052c750249fb5dd7de1f9b71cab1790743aee10508bef72546bf3bc
+  data.tar.gz: 5dd505cf1da9506c505598013ab644367da24b9542687d5cf2e1f8a5cb571ad685388bd1dad8621598035d5810a615ce85baf65efc272aa6f1642fc637cf187b

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.2
+
+### Added
+- Throttle insances can now specify the Redis instance to override the global setting
+- Redis instance now defaults to the default redis instance: `Redis.new`
+- Optimize loading LUA script to Redis; now done globally instead of per throttle instance
+
+
+## 1.0.1
+
+### Added
+- Added mutex in `SimpleThrottle.add` to ensure thread safety when adding global throttles.
+
+
+## 1.0.0
+
+### Added
+- Simple Redis backed throttle for Ruby.

data/README.md

@@ -1,3 +1,6 @@
+[![Maintainability](https://api.codeclimate.com/v1/badges/0535eef45908cc64b740/maintainability)](https://codeclimate.com/github/weheartit/simple_throttle/maintainability)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
 This gem provides a very simple throttling mechanism backed by redis for limiting access to a resource. The throttle can be thought of as a limit on the number of calls in a set time frame (i.e. 100 calls per hour). These
 
 ## Usage
@@ -9,6 +12,9 @@ SimpleThrottle.set_redis(Redis.new)
 # ...or provide a block that returns a redis client
 SimpleThrottle.set_redis{ connection_pool.redis }
 
+# ...or provide a Redis for a throttle to use
+SimpleThrottle.new("user#{user.it}", limit: 10, ttl: 60, redis: Redis.new)
+
 # Add a global throttle (max of 10 requests in 60 seconds)
 SimpleThrottle.add(:things, limit: 10, ttl: 60)
 
@@ -32,4 +38,32 @@ Calling `allowed!` will return `true` if the throttle limit has not yet been rea
 
 The throttle data is kept in redis as a list of timestamps and will be auto expired if it falls out of use. The thottles time windows are rolling time windows and more calls will be allowed as soon as possible. So, if you have a throttle of, 100 requests per hour, and the throttle kicks in, you will be able to make the next throttled call one hour after the first call being tracked, not one hour after the last call.
 
-Redis server 2.6 or greater is required.
+Redis server 2.6 or greater is required.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simple_throttle'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install simple_throttle
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/lib/simple_throttle.rb

@@ -1,30 +1,60 @@
-require 'redis'
-require 'thread'
+# frozen_string_literal: true
 
+require "redis"
 # Create a simple throttle that can be used to limit the number of request for a resouce
 # per time period. These objects are thread safe.
 class SimpleThrottle
-  
-  @@lock = Mutex.new
-  
+  # Server side Lua script that maintains the throttle in redis. The throttle is stored as a list
+  # of timestamps in milliseconds. When the script is invoked it will scan the oldest entries
+  # removing any that should be expired from the list. If the list is below the specified limit
+  # then the current entry will be added. The list is marked to expire with the oldest entry so
+  # there's no need to cleanup the lists.
+  LUA_SCRIPT = <<~LUA
+    local list_key = KEYS[1]
+    local limit = tonumber(ARGV[1])
+    local ttl = tonumber(ARGV[2])
+    local now = ARGV[3]
+    local push = tonumber(ARGV[4])
+
+    local size = redis.call('llen', list_key)
+    if size >= limit then
+      local expired = tonumber(now) - ttl
+      while size > 0 do
+        local t = redis.call('lpop', list_key)
+        if tonumber(t) > expired then
+          redis.call('lpush', list_key, t)
+          break
+        end
+        size = size - 1
+      end
+    end
+
+    if push > 0 and size < limit then
+      redis.call('rpush', list_key, now)
+      redis.call('pexpire', list_key, ttl)
+    end
+
+    return size
+  LUA
+
+  @lock = Mutex.new
+
   class << self
     # Add a global throttle that can be referenced later with the [] method.
-    def add(name, limit:, ttl:)
-      @@lock.synchronize do
-        @throttles ||= {} 
-        @throttles[name.to_s] = new(name, limit: limit, ttl: ttl)     
-      end  
+    def add(name, limit:, ttl:, redis: nil)
+      @lock.synchronize do
+        @throttles ||= {}
+        @throttles[name.to_s] = new(name, limit: limit, ttl: ttl, redis: redis)
+      end
     end
-    
+
     # Returns a globally defined throttle with the specfied name.
     def [](name)
       if defined?(@throttles) && @throttles
         @throttles[name.to_s]
-      else
-        nil
       end
     end
-    
+
     # Set the Redis instance to use for maintaining the throttle. This can either be set
     # with a hard coded value or by the value yielded by a block. If the block form is used
     # it will be invoked at runtime to get the instance. Use this method if your Redis instance
@@ -33,51 +63,66 @@ class SimpleThrottle
     def set_redis(client = nil, &block)
       @redis_client = (client || block)
     end
-    
+
     # Return the Redis instance where the throttles are stored.
     def redis
+      @redis_client ||= Redis.new
       if @redis_client.is_a?(Proc)
         @redis_client.call
       else
         @redis_client
       end
     end
+
+    private
+
+    def execute_lua_script(redis:, keys:, args:)
+      @script_sha_1 ||= redis.script(:load, LUA_SCRIPT)
+      begin
+        redis.evalsha(@script_sha_1, Array(keys), Array(args))
+      rescue Redis::CommandError => e
+        if e.message.include?("NOSCRIPT")
+          @script_sha_1 = redis.script(:load, LUA_SCRIPT)
+          retry
+        else
+          raise e
+        end
+      end
+    end
   end
-  
+
   attr_reader :name, :limit, :ttl
-  
-  # Create a new throttle with the given name. The ttl argument specifies the time
-  # range that is being used for measuring in seconds while the limit specifies how
-  # many calls are allowed in that range.
-  def initialize(name, limit:, ttl:)
+
+  # Create a new throttle
+  # @param name [String] unique name for the throttle
+  # @param ttl [Numeric] number of seconds that the throttle will remain active
+  # @param limit [Integer] number of allowed requests within the throttle ttl
+  # @param redis [Redis] Redis client to use
+  def initialize(name, ttl:, limit:, redis: nil)
     @name = name.to_s
-    @name.freeze unless @name.frozen?
+    @name = name.dup.freeze unless name.frozen?
     @limit = limit
     @ttl = ttl
-    @script_sha_1 = nil
+    @redis = redis
   end
-  
+
   # Returns true if the limit for the throttle has not been reached yet. This method
   # will also track the throttled resource as having been invoked on each call.
   def allowed!
     size = current_size(true)
-    if size < limit
-      true
-    else
-      false
-    end
+    size < limit
   end
-  
+
   # Reset a throttle back to zero.
   def reset!
-    self.class.redis.del(redis_key)
+    redis_client.del(redis_key)
   end
-  
+
   # Peek at the current number for throttled calls being tracked.
   def peek
     current_size(false)
   end
-  
+
   # Returns when the next resource call should be allowed. Note that this doesn't guarantee that
   # calling allow! will return true if the wait time is zero since other processes or threads can
   # claim the resource.
@@ -85,71 +130,33 @@ class SimpleThrottle
     if peek < limit
       0.0
     else
-      first = self.class.redis.lindex(redis_key, 0).to_f / 1000.0
+      first = redis_client.lindex(redis_key, 0).to_f / 1000.0
       delta = Time.now.to_f - first
       delta = 0.0 if delta < 0
       delta
     end
   end
-    
+
   private
-  
+
+  def redis_client
+    if @redis.is_a?(Proc)
+      @redis.call || self.class.redis
+    else
+      @redis || self.class.redis
+    end
+  end
+
   # Evaluate and execute a Lua script on the redis server that returns the number calls currently being tracked.
   # If push is set to true then a new item will be added to the list.
   def current_size(push)
-    redis = self.class.redis
-    @script_sha_1 ||= redis.script(:load, lua_script)
-    begin
-      push_arg = (push ? 1 : 0)
-      time_ms = (Time.now.to_f * 1000).round
-      ttl_ms = ttl * 1000
-      redis.evalsha(@script_sha_1, [], [redis_key, limit, ttl_ms, time_ms, push_arg])
-    rescue Redis::CommandError => e
-      if e.message.include?('NOSCRIPT'.freeze)
-        @script_sha_1 = redis.script(:load, lua_script)
-        retry
-      else
-        raise e
-      end
-    end
+    push_arg = (push ? 1 : 0)
+    time_ms = (Time.now.to_f * 1000).round
+    ttl_ms = ttl * 1000
+    self.class.send(:execute_lua_script, redis: redis_client, keys: [redis_key], args: [limit, ttl_ms, time_ms, push_arg])
   end
-  
+
   def redis_key
     "simple_throttle.#{name}"
   end
-  
-  # Server side Lua script that maintains the throttle in redis. The throttle is stored as a list
-  # of timestamps in milliseconds. When the script is invoked it will scan the oldest entries
-  # removing any that should be expired from the list. If the list is below the specified limit
-  # then the current entry will be added. The list is marked to expire with the oldest entry so
-  # there's no need to cleanup the lists.
-  def lua_script
-    <<-LUA
-    local list_key = ARGV[1]
-    local limit = tonumber(ARGV[2])
-    local ttl = tonumber(ARGV[3])
-    local now = ARGV[4]
-    local push = tonumber(ARGV[5])
-    
-    local size = redis.call('llen', list_key)
-    if size >= limit then
-      local expired = tonumber(now) - ttl
-      while size > 0 do
-        local t = redis.call('lpop', list_key)
-        if tonumber(t) > expired then
-          redis.call('lpush', list_key, t)
-          break
-        end
-        size = size - 1
-      end
-    end
-
-    if push > 0 and size < limit then
-      redis.call('rpush', list_key, now)
-      redis.call('pexpire', list_key, ttl)
-    end
-    
-    return size
-    LUA
-  end
 end

data/simple_throttle.gemspec

@@ -1,25 +1,34 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
 Gem::Specification.new do |spec|
-  spec.name          = "simple_throttle"
-  spec.version       = File.read(File.expand_path("../VERSION", __FILE__)).chomp
-  spec.authors       = ["We Heart It", "Brian Durand"]
-  spec.email         = ["dev@weheartit.com", "bbdurand@gmail.com"]
-  spec.summary       = "Simple redis backed throttling mechanism to limit access to a resource"
-  spec.description   = "Simple redis backed throttling mechanism to limit access to a resource."
-  spec.homepage      = "https://github.com/weheartit/simple_throttle"
-  spec.license       = "MIT"
+  spec.name = "simple_throttle"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["We Heart It", "Brian Durand"]
+  spec.email = ["dev@weheartit.com", "bbdurand@gmail.com"]
+
+  spec.summary = "Simple redis backed throttling mechanism to limit access to a resource"
+  spec.homepage = "https://github.com/weheartit/simple_throttle"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  ignore_files = %w[
+    .
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    bin/
+    gemfiles/
+    spec/
+  ]
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency('redis')
+  spec.add_dependency "redis"
+
+  spec.add_development_dependency "bundler"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.required_ruby_version = ">= 2.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_throttle
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - We Heart It
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2021-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -27,20 +27,6 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,21 +39,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Simple redis backed throttling mechanism to limit access to a resource.
+description: 
 email:
 - dev@weheartit.com
 - bbdurand@gmail.com
@@ -75,15 +47,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- CHANGELOG.md
 - MIT_LICENSE.txt
 - README.md
-- Rakefile
 - VERSION
 - lib/simple_throttle.rb
 - simple_throttle.gemspec
-- spec/simple_throttle_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/weheartit/simple_throttle
 licenses:
 - MIT
@@ -96,18 +65,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Simple redis backed throttling mechanism to limit access to a resource
-test_files:
-- spec/simple_throttle_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/.gitignore

@@ -1,2 +0,0 @@
-.DS_Store
-pkg

data/Rakefile

@@ -1,18 +0,0 @@
-require "bundler/gem_tasks"
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'RVM likes to call it tests'
-task :tests => :test
-
-begin
-  require 'rspec'
-  require 'rspec/core/rake_task'
-  desc 'Run the unit tests'
-  RSpec::Core::RakeTask.new(:test)
-rescue LoadError
-  task :test do
-    STDERR.puts "You must have rspec 2.0 installed to run the tests"
-  end
-end

data/spec/simple_throttle_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe SimpleThrottle do
-  
-  it "should tell if a call is allowed" do
-    throttle = SimpleThrottle.new("test_simple_throttle", limit: 3, ttl: 1)
-    throttle.reset!
-    other_throttle = SimpleThrottle.new("test_simple_throttle_2", limit: 3, ttl: 1)
-    other_throttle.reset!
-    
-    expect(throttle.peek).to eq 0
-    expect(throttle.allowed!).to eq true
-    expect(throttle.peek).to eq 1
-    expect(throttle.allowed!).to eq true
-    expect(throttle.peek).to eq 2
-    expect(throttle.allowed!).to eq true
-    expect(throttle.peek).to eq 3
-    expect(throttle.allowed!).to eq false
-    expect(throttle.peek).to eq 3
-    expect(throttle.allowed!).to eq false
-    wait_time = throttle.wait_time
-    expect(wait_time).to be > 0.0
-    expect(wait_time).to be <= 1.0
-    
-    expect(other_throttle.allowed!).to eq true
-    expect(other_throttle.peek).to eq 1
-    expect(other_throttle.wait_time).to eq 0.0
-    
-    sleep(1.1)
-
-    expect(throttle.allowed!).to eq true
-    sleep(0.3)
-    expect(throttle.allowed!).to eq true
-    sleep(0.3)
-    expect(throttle.allowed!).to eq true
-    sleep(0.3)
-    expect(throttle.allowed!).to eq false
-    sleep(0.3)
-    expect(throttle.allowed!).to eq true
-    expect(throttle.allowed!).to eq false
-  end
-  
-  it "should be able to add global throttles" do
-    SimpleThrottle.add(:test_1, limit: 4, ttl: 60)
-    SimpleThrottle.add(:test_2, limit: 10, ttl: 3600)
-    t1 = SimpleThrottle["test_1"]
-    expect(t1.name).to eq "test_1"
-    expect(t1.limit).to eq 4
-    expect(t1.ttl).to eq 60
-    t1 = SimpleThrottle[:test_2]
-    expect(t1.name).to eq "test_2"
-    expect(t1.limit).to eq 10
-    expect(t1.ttl).to eq 3600
-  end
-  
-end

data/spec/spec_helper.rb

@@ -1,14 +0,0 @@
-require File.expand_path('../../lib/simple_throttle', __FILE__)
-
-SimpleThrottle.set_redis(Redis.new)
-
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-end