pause 0.2.1 → 0.5.0

data/lib/pause/redis/adapter.rb

@@ -1,32 +1,47 @@
+# frozen_string_literal: true
+
 require 'pause/helper/timing'
 
 module Pause
   module Redis
-
     # This class encapsulates Redis operations used by Pause
     class Adapter
+      class << self
+        def redis
+          @redis ||= ::Redis.new(redis_connection_opts)
+        end
+
+        def redis_connection_opts
+          { host: Pause.config.redis_host,
+            port: Pause.config.redis_port,
+            db: Pause.config.redis_db }
+        end
+      end
 
       include Pause::Helper::Timing
       attr_accessor :resolution, :time_blocks_to_keep, :history
 
       def initialize(config)
-        @resolution = config.resolution
+        @resolution          = config.resolution
         @time_blocks_to_keep = config.history / @resolution
-        @history = config.history
+        @history             = config.history
+      end
+
+      # Override in subclasses to disable
+      def with_multi
+        redis.multi do |redis|
+          yield(redis) if block_given?
+        end
       end
 
       def increment(scope, identifier, timestamp, count = 1)
         k = tracked_key(scope, identifier)
-        redis.multi do |redis|
+        with_multi do |redis|
           redis.zincrby k, count, period_marker(resolution, timestamp)
           redis.expire k, history
         end
 
-        if redis.zcard(k) > time_blocks_to_keep
-          list = extract_set_elements(k)
-          to_remove = list.slice(0, (list.size - time_blocks_to_keep))
-          redis.zrem(k, to_remove.map(&:ts))
-        end
+        truncate_set_for(k)
       end
 
       def key_history(scope, identifier)
@@ -58,6 +73,7 @@ module Pause
       # @return count [Integer] the number of items deleted
       def delete_rate_limited_keys(scope)
         return 0 unless rate_limited_keys(scope).any?
+
         delete_tracking_keys(scope, rate_limited_keys(scope))
         redis.zremrangebyscore(rate_limited_list(scope), '-inf', '+inf').tap do |_count|
           redis.del rate_limited_list(scope)
@@ -70,7 +86,7 @@ module Pause
       end
 
       def disable(scope)
-        redis.set("internal:|#{scope}|:disabled", "1")
+        redis.set("internal:|#{scope}|:disabled", '1')
       end
 
       def enable(scope)
@@ -78,7 +94,7 @@ module Pause
       end
 
       def disabled?(scope)
-        ! enabled?(scope)
+        !enabled?(scope)
       end
 
       def enabled?(scope)
@@ -91,15 +107,21 @@ module Pause
 
       private
 
-      def delete_tracking_keys(scope, ids)
-        increment_keys = ids.map{ |key| tracked_key(scope, key) }
-        redis.del(increment_keys)
+      def redis
+        self.class.redis
       end
 
-      def redis
-        @redis_conn ||= ::Redis.new(host: Pause.config.redis_host,
-                                    port: Pause.config.redis_port,
-                                    db:   Pause.config.redis_db)
+      def truncate_set_for(k)
+        return unless redis.zcard(k) > time_blocks_to_keep
+
+        list      = extract_set_elements(k)
+        to_remove = list.slice(0, (list.size - time_blocks_to_keep)).map(&:ts)
+        redis.zrem(k, to_remove) if k && to_remove&.size&.positive?
+      end
+
+      def delete_tracking_keys(scope, ids)
+        increment_keys = ids.map { |key| tracked_key(scope, key) }
+        redis.del(increment_keys)
       end
 
       def tracked_scope(scope)
@@ -117,7 +139,7 @@ module Pause
 
       def keys(key_scope)
         redis.keys("#{key_scope}:*").map do |key|
-          key.gsub(/^#{key_scope}:/, "").tr('|','')
+          key.gsub(/^#{key_scope}:/, '').tr('|', '')
         end
       end
 

data/lib/pause/redis/sharded_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pause
   module Redis
     class OperationNotSupported < StandardError
@@ -7,28 +9,22 @@ module Pause
     # Operations that are not possible when data is sharded
     # raise an error.
     class ShardedAdapter < Adapter
-      def increment(scope, identifier, timestamp, count = 1)
-        k = tracked_key(scope, identifier)
-        redis.zincrby k, count, period_marker(resolution, timestamp)
-        redis.expire k, history
-
-        if redis.zcard(k) > time_blocks_to_keep
-          list = extract_set_elements(k)
-          to_remove = list.slice(0, (list.size - time_blocks_to_keep))
-          redis.zrem(k, to_remove.map(&:ts))
-        end
+      # Overrides real multi which is not possible when sharded.
+      def with_multi
+        yield(redis) if block_given?
       end
 
+      protected
 
-      private
-
-      def redis
-        @redis_conn ||= ::Redis.new(host: Pause.config.redis_host,
-          port: Pause.config.redis_port)
+      def redis_connection_opts
+        { host: Pause.config.redis_host,
+          port: Pause.config.redis_port }
       end
 
+      private
+
       def keys(_key_scope)
-        raise OperationNotSupported.new('Can not be executed when Pause is configured in sharded mode')
+        raise OperationNotSupported, 'Can not be executed when Pause is configured in sharded mode'
       end
     end
   end

data/lib/pause/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pause
-  VERSION = '0.2.1'
+  VERSION = '0.5.0'
 end

data/lib/pause.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'redis'
+require 'colored2'
 require 'pause/version'
 require 'pause/configuration'
 require 'pause/action'
@@ -9,15 +12,15 @@ require 'pause/redis/sharded_adapter'
 require 'pause/rate_limited_event'
 
 module Pause
-  class PeriodCheck < Struct.new(:period_seconds, :max_allowed, :block_ttl)
+  PeriodCheck = Struct.new(:period_seconds, :max_allowed, :block_ttl) do
     def <=>(other)
-      self.period_seconds <=> other.period_seconds
+      period_seconds <=> other.period_seconds
     end
   end
 
-  class SetElement < Struct.new(:ts, :count)
+  SetElement = Struct.new(:ts, :count) do
     def <=>(other)
-      self.ts <=> other.ts
+      ts <=> other.ts
     end
   end
 
@@ -27,21 +30,21 @@ module Pause
     end
 
     def adapter
-      @adapter ||= config.sharded ?
-        Pause::Redis::ShardedAdapter.new(config) :
-        Pause::Redis::Adapter.new(config)
+      @adapter ||= if config.sharded
+                     Pause::Redis::ShardedAdapter.new(config)
+                   else
+                     Pause::Redis::Adapter.new(config)
+                   end
     end
 
-    def adapter=(adapter)
-      @adapter = adapter
-    end
+    attr_writer :adapter
 
     def configure(&block)
-      @configuration = Pause::Configuration.new.configure(&block)
+      @configure ||= Pause::Configuration.new.configure(&block)
     end
 
-    def config
-      @configuration
+    def config(&block)
+      configure(&block)
     end
   end
 end

data/pause.gemspec

@@ -1,21 +1,27 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+require 'English'
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'pause/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "pause"
+  gem.name          = 'pause'
   gem.version       = Pause::VERSION
-  gem.authors       = ["Atasay Gokkaya", "Paul Henry", "Eric Saxby", "Konstantin Gredeskoul"]
-  gem.email         = %w(atasay@wanelo.com paul@wanelo.com sax@wanelo.com kig@wanelo.com)
-  gem.description   = %q(Real time rate limiting for multi-process ruby environments based on Redis)
-  gem.summary       = %q(RReal time rate limiting for multi-process ruby environments based on Redis)
-  gem.homepage      = "https://github.com/wanelo/pause"
+  gem.authors       = ['Konstantin Gredeskoul', 'Atasay Gokkaya', 'Paul Henry', 'Eric Saxby']
+  gem.email         = %w[kigster@gmail.com atasay@wanelo.com paul@wanelo.com sax@ericsaxby.com]
+  gem.summary       = 'Fast, scalable, and flexible real time rate limiting library for distributed Ruby environments backed by Redis.'
+  gem.description   = 'This gem provides highly flexible and easy to use interface to define rate limit checks, register events as they come, and verify if the rate limit is reached. Multiple checks for the same metric are easily supported. This gem is used at very high scale on several popular web sites.'
+  gem.homepage      = 'https://github.com/kigster/pause'
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.require_paths = ['lib']
 
+  gem.add_dependency 'colored2'
   gem.add_dependency 'redis'
+
+  # optional
+  # gem.add_dependency 'hiredis'
+  gem.metadata['rubygems_mfa_required'] = 'true'
 end

data/spec/pause/action_spec.rb

@@ -11,6 +11,10 @@ describe Pause::Action do
   end
 
   let(:resolution) { 10 }
+  let(:identifier) { '11112222' }
+  let(:action) { MyNotification.new(identifier) }
+  let(:other_identifier) { '8798734' }
+  let(:other_action) { MyNotification.new(other_identifier) }
   let(:history) { 60 }
   let(:configuration) { Pause::Configuration.new }
   let(:adapter) { Pause::Redis::Adapter.new(Pause.config) }
@@ -22,92 +26,178 @@ describe Pause::Action do
     allow(Pause).to receive(:adapter).and_return(adapter)
   end
 
-  let(:action) { MyNotification.new('1237612') }
-  let(:other_action) { MyNotification.new('1237613') }
-
-  describe '#increment!' do
-    it 'should increment' do
-      time = Time.now
-      Timecop.freeze time do
-        expect(Pause.adapter).to receive(:increment).with(action.scope, '1237612', time.to_i, 1)
-        action.increment!
+  RSpec.shared_examples 'an action' do
+    describe '#increment!' do
+      it 'increments' do
+        time = Time.now
+        Timecop.freeze time do
+          expect(Pause.adapter).to receive(:increment).with(action.scope, identifier, time.to_i, 1)
+          action.increment!
+        end
       end
     end
-  end
 
-  describe '#ok?' do
-    it 'should successfully return if the action is blocked or not' do
-      time = Time.now
-      Timecop.freeze time do
-        4.times do
+    describe '#ok?' do
+      it 'successfullies return if the action is blocked or not' do
+        time = Time.now
+        Timecop.freeze time do
+          4.times do
+            action.increment!
+            expect(action.ok?).to be true
+          end
           action.increment!
+          expect(action.ok?).to be false
+        end
+      end
+
+      it 'successfullies consider different period checks' do
+        time = Time.parse('Sept 22, 11:34:00')
+
+        Timecop.freeze time - 30 do
+          action.increment! 4
+          expect(action.ok?).to be true
+        end
+
+        Timecop.freeze time do
+          action.increment! 2
           expect(action.ok?).to be true
         end
-        action.increment!
+
+        Timecop.freeze time do
+          action.increment! 1
+          expect(action.ok?).to be false
+        end
+      end
+
+      it 'returns false and silently fail if redis is not available' do
+        allow(Pause::Logger).to receive(:fatal)
+        allow_any_instance_of(Redis).to receive(:zrange).and_raise Redis::CannotConnectError
+        time = period_marker(resolution, Time.now.to_i)
+
+        action.increment! 4, time - 25
+
         expect(action.ok?).to be false
       end
     end
 
-    it 'should successfully consider different period checks' do
-      time = Time.parse('Sept 22, 11:34:00')
+    describe '#analyze' do
+      context 'action should not be rate limited' do
+        it 'returns nil' do
+          expect(adapter.rate_limited?(action.scope, action.identifier)).to be false
+          expect(action.analyze).to be_nil
+        end
+      end
 
-      Timecop.freeze time - 30 do
-        action.increment! 4
-        expect(action.ok?).to be true
+      context 'action should be rate limited' do
+        it 'returns a RateLimitedEvent object' do
+          time       = Time.now
+          rate_limit = nil
+
+          Timecop.freeze time do
+            7.times { action.increment! }
+            rate_limit = action.analyze
+          end
+
+          expected_rate_limit = Pause::RateLimitedEvent.new(action, action.checks[0], 7, time.to_i)
+
+          expect(rate_limit).to be_a(Pause::RateLimitedEvent)
+          expect(rate_limit.identifier).to eq(expected_rate_limit.identifier)
+          expect(rate_limit.sum).to eq(expected_rate_limit.sum)
+          expect(rate_limit.period_check).to eq(expected_rate_limit.period_check)
+          expect(rate_limit.timestamp).to eq(expected_rate_limit.timestamp)
+        end
       end
+    end
 
-      Timecop.freeze time do
-        action.increment! 2
+    describe '#unblock' do
+      it 'unblocks the specified id' do
+        10.times { action.increment! }
+        expect(action.ok?).to be false
+        action.unblock
         expect(action.ok?).to be true
       end
+    end
 
-      Timecop.freeze time do
-        action.increment! 1
+    describe '#block_for' do
+      it 'blocks the IP for N seconds' do
+        expect(adapter).to receive(:rate_limit!).with(action.scope, action.identifier, 10).and_call_original
+        action.block_for(10)
         expect(action.ok?).to be false
       end
     end
+  end
 
-    it 'should return false and silently fail if redis is not available' do
-      allow(Pause::Logger).to receive(:fatal)
-      allow_any_instance_of(Redis).to receive(:zrange).and_raise Redis::CannotConnectError
-      time = period_marker(resolution, Time.now.to_i)
-
-      action.increment! 4, time - 25
-
-      expect(action.ok?).to be false
+  context 'actions under test' do
+    ['123456', 'hello', 0, 999_999].each do |id|
+      let(:identifier) { id }
+      let(:action) { MyNotification.new(identifier) }
+      describe "action with identifier #{id}" do
+        it_behaves_like 'an action'
+      end
     end
   end
 
-  describe '#analyze' do
-    context 'action should not be rate limited' do
-      it 'returns nil' do
-        expect(action.analyze).to be nil
-      end
+  context 'DSL usage' do
+    class CowRateLimited < Pause::Action
+      scope 'cow:moo'
+      check period_seconds: 10, max_allowed: 2, block_ttl: 40
+      check period_seconds: 20, max_allowed: 4, block_ttl: 40
     end
 
-    context 'action should be rate limited' do
-      it 'returns a RateLimitedEvent object' do
-        time = Time.now
-        rate_limit = nil
+    let(:identifier) { 'cow-moo' }
+    let(:action) { CowRateLimited.new(identifier) }
+    let(:bogus) { Struct.new(:name, :event).new }
 
-        Timecop.freeze time do
-          7.times { action.increment! }
-          rate_limit = action.analyze
+    describe '#unless_rate_limited' do
+      before { expect(bogus).to receive(:name).twice }
+
+      describe '#initialize' do
+        before { expect(bogus).to receive(:event).once }
+
+        it 'is able to use methods inside the #new block' do
+          b = bogus
+          CowRateLimited.new(identifier) do
+            unless_rate_limited { b.name } # this executes
+            unless_rate_limited { b.name } # this also executes
+            unless_rate_limited { b.name } # and this will be rate limited
+            if_rate_limited { b.event }
+          end
         end
+      end
 
-        expected_rate_limit = Pause::RateLimitedEvent.new(action, action.checks[0], 7, time.to_i)
+      it 'calls through the block' do
+        action.unless_rate_limited { bogus.name }
+        action.unless_rate_limited { bogus.name }
+        result = action.unless_rate_limited { bogus.name }
+        expect(result).to be_a(Pause::RateLimitedEvent)
+      end
 
-        expect(rate_limit).to be_a(Pause::RateLimitedEvent)
-        expect(rate_limit.identifier).to eq(expected_rate_limit.identifier)
-        expect(rate_limit.sum).to eq(expected_rate_limit.sum)
-        expect(rate_limit.period_check).to eq(expected_rate_limit.period_check)
-        expect(rate_limit.timestamp).to eq(expected_rate_limit.timestamp)
+      it 'calls through the block' do
+        3.times { action.unless_rate_limited { bogus.name } }
+      end
+
+      describe '#if_rate_limited' do
+        before { 2.times { action.unless_rate_limited { bogus.name } } }
+
+        it 'does not analyze during method call' do
+          bogus.event = 1
+          action.if_rate_limited { |event| bogus.event = event }
+          expect(bogus.event).to be_a(Pause::RateLimitedEvent)
+          expect(bogus.event.identifier).to eq(identifier)
+        end
+
+        it 'analyzes if requested' do
+          action.unless_rate_limited { bogus.name }
+          result = action.if_rate_limited { |event| bogus.event = event }
+          expect(bogus.event).to be_a(Pause::RateLimitedEvent)
+          expect(result).to eq(bogus.event)
+        end
       end
     end
   end
 
   describe '.tracked_identifiers' do
-    it 'should return all the identifiers tracked (but not blocked) so far' do
+    it 'returns all the identifiers tracked (but not blocked) so far' do
       action.increment!
       other_action.increment!
 
@@ -120,7 +210,7 @@ describe Pause::Action do
   end
 
   describe '.rate_limited_identifiers' do
-    it 'should return all the identifiers blocked' do
+    it 'returns all the identifiers blocked' do
       action.increment!(100, Time.now.to_i)
       other_action.increment!(100, Time.now.to_i)
 
@@ -133,7 +223,7 @@ describe Pause::Action do
   end
 
   describe '.unblock_all' do
-    it 'should unblock all the identifiers for a scope' do
+    it 'unblocks all the identifiers for a scope' do
       10.times { action.increment! }
       other_action.increment!
 
@@ -149,26 +239,6 @@ describe Pause::Action do
       expect(MyNotification.tracked_identifiers).to eq([other_action.identifier])
     end
   end
-
-  describe '#unblock' do
-    it 'unblocks the specified id' do
-      10.times { action.increment! }
-
-      expect(action.ok?).to be false
-
-      action.unblock
-
-      expect(action.ok?).to be true
-    end
-  end
-
-  describe '#block_for' do
-    it 'blocks the IP for N seconds' do
-      expect(adapter).to receive(:rate_limit!).with(action.scope, action.identifier, 10).and_call_original
-      action.block_for(10)
-      expect(action.ok?).to be false
-    end
-  end
 end
 
 describe Pause::Action, '.check' do
@@ -186,43 +256,43 @@ describe Pause::Action, '.check' do
     check period_seconds: 50, block_ttl: 60, max_allowed: 100
   end
 
-  it 'should define a period check on new instances' do
+  it 'defines a period check on new instances' do
     expect(ActionWithCheck.new('id').checks).to eq([
-          Pause::PeriodCheck.new(100, 150, 200)
-        ])
+                                                     Pause::PeriodCheck.new(100, 150, 200)
+                                                   ])
   end
 
-  it 'should define a period check on new instances' do
-    expect(ActionWithMultipleChecks.new('id').checks).to eq([
-          Pause::PeriodCheck.new(100, 150, 200),
-          Pause::PeriodCheck.new(200, 150, 200),
-          Pause::PeriodCheck.new(300, 150, 200)
-        ])
+  it 'defines a period check on new instances' do
+    expect(ActionWithMultipleChecks.new('id').checks).to \
+      eq([
+           Pause::PeriodCheck.new(100, 150, 200),
+           Pause::PeriodCheck.new(200, 150, 200),
+           Pause::PeriodCheck.new(300, 150, 200)
+         ])
   end
 
-  it 'should accept hash arguments' do
+  it 'accepts hash arguments' do
     expect(ActionWithHashChecks.new('id').checks).to eq([
-          Pause::PeriodCheck.new(50, 100, 60)
-        ])
+                                                          Pause::PeriodCheck.new(50, 100, 60)
+                                                        ])
   end
-
 end
 
 describe Pause::Action, '.scope' do
-  class UndefinedScopeAction < Pause::Action
+  module MyApp
+    class NoScope < ::Pause::Action
+    end
   end
 
-  it 'should raise if scope is not defined' do
-    expect {
-      UndefinedScopeAction.new('1.2.3.4').scope
-    }.to raise_error('Should implement scope. (Ex: ipn:follow)')
+  it 'raises if scope is not defined' do
+    expect(MyApp::NoScope.new('1.2.3.4').scope).to eq 'myapp.noscope'
   end
 
   class DefinedScopeAction < Pause::Action
     scope 'my:scope'
   end
 
-  it 'should set scope on class' do
+  it 'sets scope on class' do
     expect(DefinedScopeAction.new('1.2.3.4').scope).to eq('my:scope')
   end
 end
@@ -236,7 +306,7 @@ describe Pause::Action, 'enabled/disabled states' do
   before do
     Pause.configure do |c|
       c.resolution = 10
-      c.history = 10
+      c.history    = 10
     end
   end
 
@@ -245,26 +315,26 @@ describe Pause::Action, 'enabled/disabled states' do
   describe '#disable' do
     before do
       expect(action).to be_enabled
-      expect(action).to_not be_disabled
+      expect(action).not_to be_disabled
       action.disable
     end
 
     it 'disables the action' do
       expect(action).to be_disabled
-      expect(action).to_not be_enabled
+      expect(action).not_to be_enabled
     end
   end
 
   describe '#enable' do
     before do
       action.disable
-      expect(action).to_not be_enabled
+      expect(action).not_to be_enabled
       action.enable
     end
 
     it 'enables the action' do
       expect(action).to be_enabled
-      expect(action).to_not be_disabled
+      expect(action).not_to be_disabled
     end
   end
 end