rate-limit 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b73af03f6ea918dd965b1f1d89b8f7131e1fbba2b94166a397c100510c4a426
-  data.tar.gz: fcd12f564f38c214a088032b9ee912337dac4a566a1cd97c39256180e2e8e8a5
+  metadata.gz: b0f1786c2b5fde684e916bcc8733929b7d0d35cdc2807d8f511190f179019611
+  data.tar.gz: c216ce4a4f8e2e479854b61b895c87d226cceba9f8a3d6fb476852709a308ed2
 SHA512:
-  metadata.gz: 2a9e190cda1984c96ffd6d93751e56a323d783778c170a492d0b67b151d4a85ef83c88907526f48dc0cc574bdb19880a09667f2472b4e5873d54262e8b7dd976
-  data.tar.gz: b0529be97de2244366f3ac99f6192e7e649ff8574e15b44f51e2d56030dbcb9163238a1a03d77ed3b49d67c5669cba865c674216aa83dfe73877ab837aae02dd
+  metadata.gz: 25bbef68dd61abd1cb2353367af910ee5d61d2ce9f1408c66a36a2741abab62bc9b3c212552e01187c5a95121c611eeb9b16232b1b1bdcc4e486fcdc780b85e0
+  data.tar.gz: 5232a6c6f559c5161576b1f54d27a17b590c3b2d25376f8b6f0011d725dbf029bbc7b75e78d4afc6babeaea3a0acac4b9c3b643738f4e9730fbc5105241f208c

data/CHANGELOG.md

@@ -7,14 +7,40 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
-## [v0.1.0] - 2022-09-16
+## [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`
+- 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
 
@@ -26,8 +52,8 @@ and this project adheres to [Semantic Versioning].
 
 ### 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
+- 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
@@ -40,4 +66,5 @@ and this project adheres to [Semantic Versioning].
 <!-- versions -->
 
 [Unreleased]: https://github.com/catawiki/rate-limit/compare/v0.1.0...HEAD
-[v0.1.0]: https://github.com/catawiki/rate-limit/compare/v0.0.1...v0.1.0
+[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,85 +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
-result = RateLimit.throttle(topic: :login, namespace: :user_id, value: id)
+| 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   |
 
-if result.success?
-  # Do something
-end
-```
-or
 
+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
-result = RateLimit.throttle(topic: :login, namespace: :user_id, value: id)
+result = RateLimit.throttle(topic: :login, value: 123)
 
 if result.success?
   # Do something
 end
 ```
 
-#### Basic with exception `RateLimit.throttle!`
-
-```ruby
-begin
-  RateLimit.throttle_with_block!(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
-
-```ruby
-throttler = RateLimit::Worker.new(topic: :login, namespace: :user_id, value: id)
-
-begin
-  throttler.throttle_with_block! do
-    # Logic goes Here
-  end
-rescue RateLimit::Errors::LimitExceededError => e
-  # Error Handling Logic goes here
-end
-```
-
-#### Manual
 
-```ruby
-throttler = RateLimit::Worker.new(topic: :login, namespace: :user_id, value: id)
-
-unless throttler.limit_exceeded?
-  # Logic goes Here
-
-  throttler.increment_counters
-end
-```
-
-#### Nested throttles
-
-```ruby
-begin
-  RateLimit.throttle_with_block!(topic: :send_sms, namespace: :user_id, value: id) do
-    RateLimit.throttle_with_block!(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`
 
@@ -119,11 +66,11 @@ RateLimit.configure do |config|
   config.limits_file_path  = 'config/rate-limit.yml'
   config.on_success = proc { |result|
     # Success Logic Goes HERE
-    # result.topic, result.namespace, result.value
+    # result.topic, result.value
   }
   config.on_failure = proc { |result|
     # Failure Logic Goes HERE
-    # result.topic, result.namespace, result.value,  result.threshold,  result.interval
+    # result.topic, result.value,  result.threshold,  result.interval
   }
 end
 ```

data/lib/rate_limit/base.rb

@@ -4,21 +4,7 @@ module RateLimit
   module Base
     def throttle(**args)
       worker = Worker.new(**args)
-      worker.throttle
-      worker.result
-    end
-
-    def throttle_with_block!(**args, &block)
-      worker = Worker.new(**args)
-
-      worker.throttle_with_block!(&block)
-      worker.result
-    end
-
-    def throttle_only_failures_with_block!(**args, &block)
-      worker = Worker.new(**args)
-
-      worker.throttle_only_failures_with_block!(&block)
+      worker.throttle { yield if block_given? }
       worker.result
     end
 

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

@@ -3,20 +3,26 @@
 module RateLimit
   class Result
     # Attributes
-    attr_accessor :topic, :namespace, :value, :threshold, :interval
+    attr_accessor :topic, :value, :threshold, :interval
 
     # Methods
-    def initialize(worker, success)
-      @topic      = worker.topic
-      @namespace  = worker.namespace
-      @value      = worker.value
-      @threshold  = worker.exceeded_window&.threshold
-      @interval   = worker.exceeded_window&.interval
-      @success    = success
+    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

@@ -5,29 +5,12 @@ module RateLimit
     def throttle
       return failure! if reloaded_limit_exceeded?
 
-      success!
-    end
-
-    def throttle_with_block!
-      if reloaded_limit_exceeded?
-        failure!
-        raise Errors::LimitExceededError, exceeded_window
-      end
-
-      yield
-
-      success!
-    end
-
-    def throttle_only_failures_with_block!
-      return failure! if reloaded_limit_exceeded?
+      yield if block_given?
 
-      begin
-        yield
-      rescue StandardError => e
-        success!
-        raise e
-      end
+      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.1.0'
+  VERSION = '0.2.0'
 end

data/lib/rate_limit/window.rb

@@ -4,7 +4,7 @@ module RateLimit
   class Window
     attr_accessor :worker, :limit
 
-    delegate :topic, :namespace, :value, to: :worker
+    delegate :topic, :value, to: :worker
     delegate :threshold, :interval, to: :limit
 
     def initialize(worker, limit)
@@ -13,7 +13,7 @@ module RateLimit
     end
 
     def key
-      @key ||= [topic, namespace, value, interval].join(':')
+      @key ||= [topic, value, interval].join(':')
     end
 
     def cached_counter

data/lib/rate_limit/worker.rb

@@ -4,13 +4,15 @@ module RateLimit
   class Worker
     include Throttler
 
-    attr_accessor :topic, :namespace, :value, :limits, :windows, :exceeded_window, :result
-
-    def initialize(topic:, value:, namespace: nil)
-      @topic     = topic.to_s
-      @value     = value.to_i
-      @namespace = namespace&.to_s
-      @windows   = Window.find_all(worker: self, topic: @topic)
+    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
@@ -33,13 +35,15 @@ module RateLimit
 
     def success!
       increment_cache_counter
-      @result = Result.new(self, true)
+      result.success!
       RateLimit.config.success_callback(result)
     end
 
     def failure!
-      @result = Result.new(self, false)
+      result.failure!(self)
       RateLimit.config.failure_callback(result)
+
+      raise Errors::LimitExceededError, result if raise_errors
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rate-limit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mohamed Motaweh
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-19 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport