rate-limit 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b6d225525d8976ef1c3c8e7d0fdb1c71a48071357cff8f64633117a13ab714e
-  data.tar.gz: 057bf093d1271c83795c34472cf31e273353a24621bddebb86a901b48d451e8b
+  metadata.gz: b0f1786c2b5fde684e916bcc8733929b7d0d35cdc2807d8f511190f179019611
+  data.tar.gz: c216ce4a4f8e2e479854b61b895c87d226cceba9f8a3d6fb476852709a308ed2
 SHA512:
-  metadata.gz: 2e6a6fe077419b22d5dcc5357fdf127ab7c944aff6e1bf9d44ece39cf56f1fc1b6b12ac400aa1a2ffdeab9964f90f7739952cda796b3f23a82748410c64b324b
-  data.tar.gz: 19f68ffd995fca03b3c6787a208649b2c11c2206dd598a6b82feea25b51451817a3f354ca5de7fd9435a6fb6a61b8ac763db37a9dc2535425627eeccfc976333
+  metadata.gz: 25bbef68dd61abd1cb2353367af910ee5d61d2ce9f1408c66a36a2741abab62bc9b3c212552e01187c5a95121c611eeb9b16232b1b1bdcc4e486fcdc780b85e0
+  data.tar.gz: 5232a6c6f559c5161576b1f54d27a17b590c3b2d25376f8b6f0011d725dbf029bbc7b75e78d4afc6babeaea3a0acac4b9c3b643738f4e9730fbc5105241f208c

data/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog],
+and this project adheres to [Semantic Versioning].
+
+## [Unreleased]
+
+## [v0.2.0] - 2022-10-05
+
+### Added
+
+- added `RateLimit::Errors::LimitExceededError#result`
+- added `Worker#raise_errors`
+- added `Worker#only_failures`
+
+### Changed
+
+- changed `RateLimit::Result.initialize`
+
+### Removed
+
+- removed `RateLimit::Result#namespace`
+- removed `RateLimit::Worker#namespace`
+- removed `RateLimit::Errors::LimitExceededError#namespace`
+- removed `RateLimit::Errors::LimitExceededError#worker`
+- removed `RateLimit.throttle_with_block!` and `Worker#throttle_with_block!` in favour of `.throttle` with `{ raise_errors: true }` option
+- removed `RateLimit.throttle_only_failures_with_block!` and `Worker#throttle_only_failures_with_block!` in favour of `.throttle` with `{ only_failures: true }` option
+
+
+### Fixed
+
+- https://github.com/catawiki/rate-limit/issues/16 String Values are not respected
+
+## [v0.1.0] - 2022-09-19
+
+
+### Added
+
+- https://github.com/catawiki/rate-limit/pull/11 `RateLimit::Result` class
+- https://github.com/catawiki/rate-limit/pull/12 `RateLimit::Worker` class
+- https://github.com/catawiki/rate-limit/pull/13 `RateLimit::Config#on_success` and `RateLimit::Config#on_failure`
+
+### Changed
+
+- `RateLimit.throttle` to not accept block
+- `RateLimit.throttle` to return `RateLimit::Result` object
+- `RateLimit::Throttler` from class to module while moving responsibilities to `RateLimit::Worker` class
+- renamed `RateLimit.throttle!` to `RateLimit.throttle_with_block!`
+- renamed `RateLimit.throttle_only_failures` to `RateLimit.throttle_only_failures_with_block!`
+
+### Fixed
+
+- https://github.com/catawiki/rate-limit/issues/7 Symbol topic names does not load the correct limits
+- https://github.com/catawiki/rate-limit/issues/6 Main Module (RateLimit) fails to autoload
+
+
+## v0.0.1 - 2022-09-09
+
+- Initial gem release
+
+[Keep a Changelog]: https://keepachangelog.com/en/1.0.0/
+[Semantic Versioning]: https://semver.org/spec/v2.0.0.html
+
+<!-- versions -->
+
+[Unreleased]: https://github.com/catawiki/rate-limit/compare/v0.1.0...HEAD
+[v0.2.0]: https://github.com/catawiki/rate-limit/compare/v0.1.0...v0.2.0
+[v0.1.0]: https://github.com/catawiki/rate-limit/compare/v0.0.1...v0.1.0

data/README.md

@@ -3,12 +3,12 @@
 
 Protect your Ruby apps from bad actors. RateLimit allows you to set permissions as to whether certain number of feature calls are valid or not for a specific entity (user, phone number, email address, etc...). 
 
-This gem mainly provides brute-force protection by throttling attepmts for a specific entity id (i.e user_id). However it could also be used to throttle based on ip address (we recommend that you consider using [Rack::Attack](https://github.com/rack/rack-attack) for more optimized ip throttling)
+This gem mainly provides brute-force protection by throttling attempts for a specific entity id (i.e user_id). However it could also be used to throttle based on ip address (we recommend that you consider using [Rack::Attack](https://github.com/rack/rack-attack) for more optimized ip throttling)
 
 #### Common Use Cases
 * [Login] Brute-force attempts for a spefic account
-* [SMS Spam] Brute-force attempts for requesting Phone Verification SMS for a spefic user_id
-* [SMS Spam] Brute-force attempts for requesting  Phone Verification SMS for a spefic phone_number
+* [SMS Spam] Brute-force attempts for requesting Phone Verification SMS for a specific user_id
+* [SMS Spam] Brute-force attempts for requesting  Phone Verification SMS for a specific phone_number
 * [Verifications] Brute-force attempts for entering verification codes
 * [Redeem] Brute-force attempts to redeem voucher codes from a specific account
 
@@ -28,81 +28,32 @@ Or install it yourself as:
 
     $ gem install rate-limit
 
-## Usage
+## Basic Usage
 
-#### Basic `RateLimit.throttle`
+### [`RateLimit.throttle`](https://github.com/catawiki/rate-limit/wiki/Throttling)
+The throttle method expects the following options
 
-```ruby
-if RateLimit.throttle(topic: :login, namespace: :user_id, value: id)
-  # Do something
-end
-```
-or
+| Option           | Description                                                                     | Examples                              |
+| ---------------- | ------------------------------------------------------------------------------- | ------------------------------------- |
+| topic            | The topic you would like to throttle                                            | "login", "send_sms", "redeem_voucher" |
+| value            | The identifier of the unique entity that is throttled based on the topic limits | user_id, phone_number, voucher_code   |
 
-```ruby
-if RateLimit.throttle(topic: :login, value: id)
-  # Do something
-end
-```
 
-#### Basic with exception `RateLimit.throttle!`
+The `throttle` method checks if the given value did exceed the defined limits for the given topic. If the limit is exceeded then it returns [RateLimit::Result](https://github.com/catawiki/rate-limit/wiki/RateLimit::Result) Object, where `result.success?` will be `false`. Otherwise, it increments the attempts counter in the cache and sets `result.success?` to `true`.
 
+#### Example
 ```ruby
-begin
-  RateLimit.throttle!(topic: :send_sms, namespace: :user_id, value: id) do
-    # Logic goes Here
-  end
-rescue RateLimit::Errors::LimitExceededError => e
-  # Error Handling Logic goes here
-  e.topic     # :login
-  e.namespace # :user_id
-  e.value     # id
-  e.threshold # 2
-  e.interval  # 60
-end
-```
-
-#### Advanced
+result = RateLimit.throttle(topic: :login, value: 123)
 
-```ruby
-throttler = RateLimit::Throttler.new(topic: :login, namespace: :user_id, value: id)
-
-begin
-  throttler.perform! do
-    # Logic goes Here
-  end
-rescue RateLimit::Errors::LimitExceededError => e
-  # Error Handling Logic goes here
-end
-```
-
-#### Manual
-
-```ruby
-throttler = RateLimit::Throttler.new(topic: :login, namespace: :user_id, value: id)
-
-unless throttler.limit_exceeded?
-  # Logic goes Here
-
-  throttler.increment_counters
+if result.success?
+  # Do something
 end
 ```
 
-#### Nested throttles
 
-```ruby
-begin
-  RateLimit.throttle!(topic: :send_sms, namespace: :user_id, value: id) do
-    RateLimit.throttle!(topic: :send_sms, namespace: :phone_number, value: number) do
-      # Logic goes Here
-    end
-  end
-rescue RateLimit::Errors::LimitExceededError => e
-  # Error Handling Logic goes here
-end
-```
+Please check the [Wiki](https://github.com/catawiki/rate-limit/wiki) for advanced throttling and options.
 
-### Config
+## [Configuration](https://github.com/catawiki/rate-limit/wiki/Configuration)
 
 Customize the configuration by adding the following block to `config/initializers/rate_limit.rb`
 
@@ -113,6 +64,14 @@ RateLimit.configure do |config|
   config.default_interval  = 60
   config.default_threshold = 2
   config.limits_file_path  = 'config/rate-limit.yml'
+  config.on_success = proc { |result|
+    # Success Logic Goes HERE
+    # result.topic, result.value
+  }
+  config.on_failure = proc { |result|
+    # Failure Logic Goes HERE
+    # result.topic, result.value,  result.threshold,  result.interval
+  }
 end
 ```
 

data/lib/rate-limit.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'rate_limit'

data/lib/rate_limit/base.rb

@@ -3,29 +3,21 @@
 module RateLimit
   module Base
     def throttle(**args)
-      throttle!(**args) { yield if block_given? }
-    rescue Errors::LimitExceededError => _e
-      false
-    end
-
-    def throttle!(**args)
-      Throttler.new(**args).perform! { yield if block_given? }
-    end
-
-    def throttle_only_failures!(**args)
-      Throttler.new(**args).perform_only_failures! { yield if block_given? }
+      worker = Worker.new(**args)
+      worker.throttle { yield if block_given? }
+      worker.result
     end
 
     def limit_exceeded?(**args)
-      Throttler.new(**args).limit_exceeded?
+      Worker.new(**args).reloaded_limit_exceeded?
     end
 
     def reset_counters(**args)
-      Throttler.new(**args).clear_cache_counter
+      Worker.new(**args).clear_cache_counter
     end
 
     def increment_counters(**args)
-      Throttler.new(**args).increment_cache_counter
+      Worker.new(**args).increment_cache_counter
     end
   end
 end

data/lib/rate_limit/config.rb

@@ -9,6 +9,8 @@ module RateLimit
     attr_accessor :default_interval,
                   :default_threshold,
                   :limits_file_path,
+                  :on_success,
+                  :on_failure,
                   :fail_safe,
                   :redis
 
@@ -24,6 +26,14 @@ module RateLimit
       raw_limits[topic] || Defaults.raw_limits
     end
 
+    def success_callback(*args)
+      on_success&.call(*args)
+    end
+
+    def failure_callback(*args)
+      on_failure&.call(*args)
+    end
+
     private
 
     def raw_limits

data/lib/rate_limit/errors/limit_exceeded_error.rb

@@ -3,18 +3,18 @@
 module RateLimit
   module Errors
     class LimitExceededError < StandardError
-      attr_reader :window
+      attr_reader :result
 
-      delegate :topic, :namespace, :value, :threshold, :interval, to: :window
+      delegate :topic, :value, :threshold, :interval, to: :result
 
-      def initialize(window)
-        @window = window
+      def initialize(result)
+        @result = result
 
         super(custom_message)
       end
 
       def custom_message
-        "#{topic}: #{namespace} has exceeded #{threshold} in #{interval} seconds"
+        "#{result.topic}: has exceeded #{result.threshold} in #{result.interval} seconds"
       end
     end
   end

data/lib/rate_limit/result.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RateLimit
+  class Result
+    # Attributes
+    attr_accessor :topic, :value, :threshold, :interval
+
+    # Methods
+    def initialize(topic:, value:)
+      @topic = topic
+      @value = value
+    end
+
+    def success?
+      @success
+    end
+
+    def success!
+      @success = true
+    end
+
+    def failure!(worker)
+      @success = false
+      @threshold  = worker.exceeded_window&.threshold
+      @interval   = worker.exceeded_window&.interval
+    end
+  end
+end

data/lib/rate_limit/throttler.rb

@@ -1,57 +1,16 @@
 # frozen_string_literal: true
 
 module RateLimit
-  class Throttler
-    attr_accessor :topic, :namespace, :value, :limits, :windows
-
-    def initialize(topic:, value:, namespace: nil)
-      @topic     = topic.to_s
-      @value     = value.to_i
-      @namespace = namespace&.to_s
-      @windows   = Limit.fetch(topic).map { |limit| Window.new(self, limit) }
-    end
-
-    def perform!
-      validate_limit!
+  module Throttler
+    def throttle
+      return failure! if reloaded_limit_exceeded?
 
       yield if block_given?
 
-      increment_cache_counter
-
-      true
-    end
-
-    def perform_only_failures!
-      validate_limit!
-
-      begin
-        yield if block_given?
-      rescue StandardError => e
-        increment_cache_counter
-        raise e
-      end
-
-      true
-    end
-
-    def limit_exceeded?
-      Window.find_exceeded(windows).present?
-    end
-
-    def increment_cache_counter
-      Window.increment_cache_counter(windows)
-    end
-
-    def clear_cache_counter
-      Window.clear_cache_counter(windows)
-    end
-
-    private
-
-    def validate_limit!
-      exceeded_window = Window.find_exceeded(windows)
-
-      raise Errors::LimitExceededError, exceeded_window if exceeded_window
+      return success! unless only_failures
+    rescue StandardError => e
+      success! unless e.is_a?(Errors::LimitExceededError)
+      raise e
     end
   end
 end

data/lib/rate_limit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RateLimit
-  VERSION = '0.0.1'
+  VERSION = '0.2.0'
 end

data/lib/rate_limit/window.rb

@@ -2,18 +2,18 @@
 
 module RateLimit
   class Window
-    attr_accessor :throttler, :limit
+    attr_accessor :worker, :limit
 
-    delegate :topic, :namespace, :value, to: :throttler
+    delegate :topic, :value, to: :worker
     delegate :threshold, :interval, to: :limit
 
-    def initialize(throttler, limit)
-      @throttler = throttler
-      @limit     = limit
+    def initialize(worker, limit)
+      @worker = worker
+      @limit = limit
     end
 
     def key
-      @key ||= [topic, namespace, value, interval].join(':')
+      @key ||= [topic, value, interval].join(':')
     end
 
     def cached_counter
@@ -21,6 +21,10 @@ module RateLimit
     end
 
     class << self
+      def find_all(topic:, worker:)
+        Limit.fetch(topic).map { |limit| Window.new(worker, limit) }
+      end
+
       def find_exceeded(windows)
         windows.find { |w| w.cached_counter >= w.threshold }
       end

data/lib/rate_limit/worker.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RateLimit
+  class Worker
+    include Throttler
+
+    attr_accessor :topic, :value, :limits, :windows, :exceeded_window, :result, :raise_errors, :only_failures
+
+    def initialize(topic:, value:, raise_errors: false, only_failures: false)
+      @topic         = topic.to_s
+      @value         = value.to_s
+      @windows       = Window.find_all(worker: self, topic: @topic)
+      @result        = Result.new(topic: @topic, value: @value)
+      @raise_errors = raise_errors
+      @only_failures = only_failures
+    end
+
+    def increment_cache_counter
+      Window.increment_cache_counter(windows)
+    end
+
+    def clear_cache_counter
+      Window.clear_cache_counter(windows)
+    end
+
+    def reloaded_limit_exceeded?
+      @exceeded_window = Window.find_exceeded(windows)
+
+      limit_exceeded?
+    end
+
+    def limit_exceeded?
+      exceeded_window.present?
+    end
+
+    def success!
+      increment_cache_counter
+      result.success!
+      RateLimit.config.success_callback(result)
+    end
+
+    def failure!
+      result.failure!(self)
+      RateLimit.config.failure_callback(result)
+
+      raise Errors::LimitExceededError, result if raise_errors
+    end
+  end
+end

data/lib/rate_limit.rb

@@ -2,9 +2,11 @@
 
 require 'active_support/core_ext/module'
 require_relative 'rate_limit/configurable'
+require_relative 'rate_limit/result'
 require_relative 'rate_limit/cache'
 require_relative 'rate_limit/window'
 require_relative 'rate_limit/throttler'
+require_relative 'rate_limit/worker'
 require_relative 'rate_limit/limit'
 require_relative 'rate_limit/errors/limit_exceeded_error'
 require_relative 'rate_limit/base'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rate-limit
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Mohamed Motaweh
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-09 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -60,6 +60,7 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- lib/rate-limit.rb
 - lib/rate_limit.rb
 - lib/rate_limit/base.rb
 - lib/rate_limit/cache.rb
@@ -69,9 +70,11 @@ files:
 - lib/rate_limit/configurable.rb
 - lib/rate_limit/errors/limit_exceeded_error.rb
 - lib/rate_limit/limit.rb
+- lib/rate_limit/result.rb
 - lib/rate_limit/throttler.rb
 - lib/rate_limit/version.rb
 - lib/rate_limit/window.rb
+- lib/rate_limit/worker.rb
 homepage: https://github.com/catawiki/rate-limit
 licenses:
 - MIT
@@ -95,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: A Rate Limiting Gem