pause 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cebe59883ec6e4803896b89e61d88c53f43902cc
-  data.tar.gz: 86067516015b359cbe2becb8d2e5b71748484f70
+  metadata.gz: b9d25d869302d10074000e45ae903a1d28d66ccc
+  data.tar.gz: d3bcfbce3b73826e20481aa28f6a1a70dc61f172
 SHA512:
-  metadata.gz: 3538a2c610971934961be482f4531e43a1b614c4d48786484592f4e9c170ef5e4694055d1e8efb80839c62d636c93f997907fd5c9ed1df181adcf8bb6711d361
-  data.tar.gz: bb3921bf9935e98176a073ac2dabcf43c1786c75ce5e532b04497dba4a8dff039d28ed9a1f88b12fd9a5da6052259e762e1cba1a66bd87bf7288f7d771021e42
+  metadata.gz: 812f85e93696fb48483f3d9096a9a6406509361a5145e3cd66614b57bb83e879ec4aa3fd749876a842966a2dd73a54344b0ea957d8e75ffd0bb0653c72aa9670
+  data.tar.gz: 29d51c794c8776748fa282ce63c308db83cc6092cbc6f0e407bb37b76140fa9fcc7bcd34847ecbc290f9e5f1b8e022b91e2f3ad17f700dfb5802c7aadf5e867c

data/.travis.yml

@@ -5,6 +5,6 @@ script: "bundle exec rspec"
 notifications:
   email:
     recipients:
-      - dev@wanelo.com
+      - dev-info@wanelo.com
     on_success: never
     on_failure: always

data/Gemfile

@@ -5,3 +5,11 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in pause.gemspec
 gemspec
+
+gem 'fakeredis'
+gem 'guard-rspec'
+gem 'pry-nav'
+gem 'rake'
+gem 'rb-fsevent'
+gem 'rspec'
+gem 'timecop'

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/pause.rb

@@ -1,9 +1,11 @@
 require 'redis'
-require "pause/version"
-require "pause/configuration"
-require "pause/action"
-require "pause/analyzer"
-require "pause/redis/adapter"
+require 'pause/version'
+require 'pause/configuration'
+require 'pause/action'
+require 'pause/analyzer'
+require 'pause/logger'
+require 'pause/redis/adapter'
+require 'pause/redis/sharded_adapter'
 require 'pause/rate_limited_event'
 
 module Pause
@@ -25,7 +27,13 @@ module Pause
     end
 
     def adapter
-      @adapter ||= Pause::Redis::Adapter.new(config)
+      @adapter ||= config.sharded ?
+        Pause::Redis::ShardedAdapter.new(config) :
+        Pause::Redis::Adapter.new(config)
+    end
+
+    def adapter=(adapter)
+      @adapter = adapter
     end
 
     def configure(&block)

data/lib/pause/action.rb

@@ -58,7 +58,7 @@ module Pause
     end
 
     def increment!(count = 1, timestamp = Time.now.to_i)
-      adapter.increment(key, timestamp, count)
+      adapter.increment(scope, identifier, timestamp, count)
     end
 
     def rate_limited?
@@ -68,7 +68,7 @@ module Pause
     def ok?
       Pause.analyzer.check(self).nil?
     rescue ::Redis::CannotConnectError => e
-      $stderr.puts "Error connecting to redis: #{e.inspect}"
+      Pause::Logger.fatal "Error connecting to redis: #{e.inspect} #{e.message} #{e.backtrace.join("\n")}"
       false
     end
 
@@ -92,10 +92,6 @@ module Pause
       adapter.delete_rate_limited_key(scope, identifier)
     end
 
-    def key
-      "#{self.scope}:#{identifier}"
-    end
-
     # Actions can be globally disabled or re-enabled in a persistent
     # way.
     #

data/lib/pause/analyzer.rb

@@ -6,14 +6,14 @@ module Pause
 
     def check(action)
       timestamp = period_marker(Pause.config.resolution, Time.now.to_i)
-      set = adapter.key_history(action.key)
+      set = adapter.key_history(action.scope, action.identifier)
       action.checks.each do |period_check|
         start_time = timestamp - period_check.period_seconds
         set.reverse.inject(0) do |sum, element|
           break if element.ts < start_time
           sum += element.count
           if sum >= period_check.max_allowed
-            adapter.rate_limit!(action.key, period_check.block_ttl)
+            adapter.rate_limit!(action.scope, action.identifier, period_check.block_ttl)
             # Note that Time.now is different from period_marker(resolution, Time.now), which
             # rounds down to the nearest (resolution) seconds
             return Pause::RateLimitedEvent.new(action, period_check, sum, Time.now.to_i)

data/lib/pause/configuration.rb

@@ -1,6 +1,6 @@
 module Pause
   class Configuration
-    attr_writer :redis_host, :redis_port, :redis_db, :resolution, :history
+    attr_writer :redis_host, :redis_port, :redis_db, :resolution, :history, :sharded
 
     def configure
       yield self
@@ -26,5 +26,9 @@ module Pause
     def history
       (@history || 86400).to_i
     end
+
+    def sharded
+      @sharded || false
+    end
   end
 end

data/lib/pause/logger.rb

@@ -0,0 +1,11 @@
+module Pause
+  class Logger
+    def self.puts message
+      STDOUT.puts message
+    end
+
+    def self.fatal message
+      STDERR.puts message
+    end
+  end
+end

data/lib/pause/redis/adapter.rb

@@ -15,8 +15,8 @@ module Pause
         @history = config.history
       end
 
-      def increment(key, timestamp, count = 1)
-        k = white_key(key)
+      def increment(scope, identifier, timestamp, count = 1)
+        k = tracked_key(scope, identifier)
         redis.multi do |redis|
           redis.zincrby k, count, period_marker(resolution, timestamp)
           redis.expire k, history
@@ -29,40 +29,47 @@ module Pause
         end
       end
 
-      def key_history(key)
-        extract_set_elements(white_key(key))
+      def key_history(scope, identifier)
+        extract_set_elements(tracked_key(scope, identifier))
       end
 
-      def rate_limit!(key, block_ttl)
-        redis.setex(rate_limited_key(key), block_ttl, nil)
+      def rate_limit!(scope, identifier, block_ttl)
+        timestamp = Time.now.to_i + block_ttl
+        redis.zadd rate_limited_list(scope), timestamp, identifier
+        expire_block_list(scope)
       end
 
-      def rate_limited?(key)
-        !!redis.get(rate_limited_key(key))
+      def rate_limited?(scope, identifier)
+        blocked_until = redis.zscore(rate_limited_list(scope), identifier)
+        !!blocked_until && blocked_until > Time.now.to_i
       end
 
       def all_keys(scope)
-        keys(white_key(scope))
+        keys(tracked_scope(scope))
       end
 
       def rate_limited_keys(scope)
-        keys(rate_limited_key(scope))
+        redis.zrangebyscore rate_limited_list(scope), Time.now.to_i, '+inf'
       end
 
+      # For a scope, delete the entire sorted set that holds the block list.
+      # Also delete the original tracking information, so we don't immediately re-block the id
       def delete_rate_limited_keys(scope)
-        delete_rate_limited_ids scope, rate_limited_keys(scope)
+        delete_tracking_keys(scope, rate_limited_keys(scope))
+        redis.del rate_limited_list(scope)
       end
 
       def delete_rate_limited_key(scope, id)
-        delete_rate_limited_ids scope, [id]
+        delete_tracking_keys(scope, [id])
+        redis.zrem rate_limited_list(scope), id
       end
 
       def disable(scope)
-        redis.set("disabled:#{scope}", "1")
+        redis.set("internal:|#{scope}|:disabled", "1")
       end
 
       def enable(scope)
-        redis.del("disabled:#{scope}")
+        redis.del("internal:|#{scope}|:disabled")
       end
 
       def disabled?(scope)
@@ -70,15 +77,18 @@ module Pause
       end
 
       def enabled?(scope)
-        redis.keys("disabled:#{scope}").first.nil?
+        redis.get("internal:|#{scope}|:disabled").nil?
+      end
+
+      def expire_block_list(scope)
+        redis.zremrangebyscore rate_limited_list(scope), '-inf', Time.now.to_i
       end
 
       private
 
-      def delete_rate_limited_ids(scope, ids)
-        increment_keys = ids.map{ |key| white_key(scope, key) }
-        rate_limited_keys = ids.map{ |key| rate_limited_key(scope, key) }
-        redis.del(increment_keys + rate_limited_keys)
+      def delete_tracking_keys(scope, ids)
+        increment_keys = ids.map{ |key| tracked_key(scope, key) }
+        redis.del(increment_keys)
       end
 
       def redis
@@ -87,22 +97,27 @@ module Pause
                                     db:   Pause.config.redis_db)
       end
 
-      def white_key(scope, key = nil)
-        ["i", scope, key].compact.join(':')
+      def tracked_scope(scope)
+        ["i", scope].join(':')
+      end
+
+      def tracked_key(scope, identifier)
+        id = "|#{identifier}|"
+        [tracked_scope(scope), id].join(':')
       end
 
-      def rate_limited_key(scope, key = nil)
-        ["b", scope, key].compact.join(':')
+      def rate_limited_list(scope)
+        "b:|#{scope}|"
       end
 
       def keys(key_scope)
         redis.keys("#{key_scope}:*").map do |key|
-          key.gsub(/^#{key_scope}:/, "")
+          key.gsub(/^#{key_scope}:/, "").tr('|','')
         end
       end
 
       def extract_set_elements(key)
-        (redis.zrange key, 0, -1, :with_scores => true).map do |slice|
+        (redis.zrange key, 0, -1, with_scores: true).map do |slice|
           Pause::SetElement.new(slice[0].to_i, slice[1].to_i)
         end.sort
       end

data/lib/pause/redis/sharded_adapter.rb

@@ -0,0 +1,17 @@
+module Pause
+  module Redis
+    class OperationNotSupported < StandardError
+    end
+
+    # This class encapsulates Redis operations used by Pause.
+    # Operations that are not possible when data is sharded
+    # raise an error.
+    class ShardedAdapter < Adapter
+      private
+
+      def keys(_key_scope)
+        raise OperationNotSupported.new("Can not be executed when Pause is configured in sharded mode")
+      end
+    end
+  end
+end

data/lib/pause/version.rb

@@ -1,3 +1,3 @@
 module Pause
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/pause.gemspec

@@ -18,10 +18,4 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency 'redis'
-
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'fakeredis'
-  gem.add_development_dependency 'timecop'
-  gem.add_development_dependency 'guard-rspec'
-  gem.add_development_dependency 'rb-fsevent'
 end

data/spec/pause/action_spec.rb

@@ -15,9 +15,10 @@ describe Pause::Action do
   let(:configuration) { Pause::Configuration.new }
 
   before do
-    Pause.stub(:config).and_return(configuration)
-    Pause.config.stub(:resolution).and_return(resolution)
-    Pause.config.stub(:history).and_return(history)
+    allow(Pause).to receive(:config).and_return(configuration)
+    allow(Pause.config).to receive(:resolution).and_return(resolution)
+    allow(Pause.config).to receive(:history).and_return(history)
+    allow(Pause).to receive(:adapter).and_return(Pause::Redis::Adapter.new(Pause.config))
   end
 
   let(:action) { MyNotification.new("1237612") }
@@ -27,7 +28,7 @@ describe Pause::Action do
     it "should increment" do
       time = Time.now
       Timecop.freeze time do
-        Pause.adapter.should_receive(:increment).with(action.key, time.to_i, 1)
+        expect(Pause.adapter).to receive(:increment).with(action.scope, '1237612', time.to_i, 1)
         action.increment!
       end
     end
@@ -39,41 +40,47 @@ describe Pause::Action do
       Timecop.freeze time do
         4.times do
           action.increment!
-          action.ok?.should be_true
+          expect(action.ok?).to be true
         end
         action.increment!
-        action.ok?.should be_false
+        expect(action.ok?).to be false
       end
     end
 
     it "should successfully consider different period checks" do
-      time = period_marker(resolution, Time.now.to_i)
-
-      action.increment! 4, time - 25
-      action.ok?.should be_true
+      time = Time.parse('Sept 22, 11:34:00')
 
-      action.increment! 2, time - 3
-      action.ok?.should be_true
+      Timecop.freeze time - 30 do
+        action.increment! 4
+        expect(action.ok?).to be true
+      end
 
-      action.increment! 1, time
+      Timecop.freeze time do
+        action.increment! 2
+        expect(action.ok?).to be true
+      end
 
-      action.ok?.should be_false
+      Timecop.freeze time do
+        action.increment! 1
+        expect(action.ok?).to be false
+      end
     end
 
     it "should return false and silently fail if redis is not available" do
-      Redis.any_instance.stub(:zrange) { raise Redis::CannotConnectError }
+      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
 
-      action.ok?.should be_false
+      expect(action.ok?).to be false
     end
   end
 
   describe "#analyze" do
     context "action should not be rate limited" do
       it "returns nil" do
-        action.analyze.should be_nil
+        expect(action.analyze).to be nil
       end
     end
 
@@ -89,11 +96,11 @@ describe Pause::Action do
 
         expected_rate_limit = Pause::RateLimitedEvent.new(action, action.checks[0], 7, time.to_i)
 
-        rate_limit.should be_a(Pause::RateLimitedEvent)
-        rate_limit.identifier.should == expected_rate_limit.identifier
-        rate_limit.sum.should == expected_rate_limit.sum
-        rate_limit.period_check.should == expected_rate_limit.period_check
-        rate_limit.timestamp.should == expected_rate_limit.timestamp
+        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
@@ -106,8 +113,8 @@ describe Pause::Action do
       action.ok?
       other_action.ok?
 
-      MyNotification.tracked_identifiers.should include(action.identifier)
-      MyNotification.tracked_identifiers.should include(other_action.identifier)
+      expect(MyNotification.tracked_identifiers).to include(action.identifier)
+      expect(MyNotification.tracked_identifiers).to include(other_action.identifier)
     end
   end
 
@@ -119,8 +126,8 @@ describe Pause::Action do
       action.ok?
       other_action.ok?
 
-      MyNotification.rate_limited_identifiers.should include(action.identifier)
-      MyNotification.rate_limited_identifiers.should include(other_action.identifier)
+      expect(MyNotification.rate_limited_identifiers).to include(action.identifier)
+      expect(MyNotification.rate_limited_identifiers).to include(other_action.identifier)
     end
   end
 
@@ -132,13 +139,13 @@ describe Pause::Action do
       action.ok?
       other_action.ok?
 
-      MyNotification.tracked_identifiers.should include(action.identifier, other_action.identifier)
-      MyNotification.rate_limited_identifiers.should == [action.identifier]
+      expect(MyNotification.tracked_identifiers).to include(action.identifier, other_action.identifier)
+      expect(MyNotification.rate_limited_identifiers).to eq([action.identifier])
 
       MyNotification.unblock_all
 
-      MyNotification.rate_limited_identifiers.should be_empty
-      MyNotification.tracked_identifiers.should == [other_action.identifier]
+      expect(MyNotification.rate_limited_identifiers).to be_empty
+      expect(MyNotification.tracked_identifiers).to eq([other_action.identifier])
     end
   end
 
@@ -146,11 +153,11 @@ describe Pause::Action do
     it 'unblocks the specified id' do
       10.times { action.increment! }
 
-      expect(action.ok?).to be_false
+      expect(action.ok?).to be false
 
       action.unblock
 
-      expect(action.ok?).to be_true
+      expect(action.ok?).to be true
     end
   end
 end
@@ -171,23 +178,23 @@ describe Pause::Action, ".check" do
   end
 
   it "should define a period check on new instances" do
-    ActionWithCheck.new("id").checks.should == [
-        Pause::PeriodCheck.new(100, 150, 200)
-    ]
+    expect(ActionWithCheck.new("id").checks).to eq([
+          Pause::PeriodCheck.new(100, 150, 200)
+        ])
   end
 
   it "should define a period check on new instances" do
-    ActionWithMultipleChecks.new("id").checks.should == [
-        Pause::PeriodCheck.new(100, 150, 200),
-        Pause::PeriodCheck.new(200, 150, 200),
-        Pause::PeriodCheck.new(300, 150, 200)
-    ]
+    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
-    ActionWithHashChecks.new("id").checks.should == [
-        Pause::PeriodCheck.new(50, 100, 60)
-    ]
+    expect(ActionWithHashChecks.new("id").checks).to eq([
+          Pause::PeriodCheck.new(50, 100, 60)
+        ])
   end
 
 end
@@ -197,9 +204,9 @@ describe Pause::Action, ".scope" do
   end
 
   it "should raise if scope is not defined" do
-    lambda {
+    expect {
       UndefinedScopeAction.new("1.2.3.4").scope
-    }.should raise_error("Should implement scope. (Ex: ipn:follow)")
+    }.to raise_error("Should implement scope. (Ex: ipn:follow)")
   end
 
   class DefinedScopeAction < Pause::Action
@@ -207,7 +214,7 @@ describe Pause::Action, ".scope" do
   end
 
   it "should set scope on class" do
-    DefinedScopeAction.new("1.2.3.4").scope.should == "my:scope"
+    expect(DefinedScopeAction.new("1.2.3.4").scope).to eq("my:scope")
   end
 end
 
@@ -228,27 +235,27 @@ describe Pause::Action, "enabled/disabled states" do
 
   describe "#disable" do
     before do
-      action.should be_enabled
-      action.should_not be_disabled
+      expect(action).to be_enabled
+      expect(action).to_not be_disabled
       action.disable
     end
 
     it "disables the action" do
-      action.should be_disabled
-      action.should_not be_enabled
+      expect(action).to be_disabled
+      expect(action).to_not be_enabled
     end
   end
 
   describe "#enable" do
     before do
       action.disable
-      action.should_not be_enabled
+      expect(action).to_not be_enabled
       action.enable
     end
 
     it "enables the action" do
-      action.should be_enabled
-      action.should_not be_disabled
+      expect(action).to be_enabled
+      expect(action).to_not be_disabled
     end
   end
 end

data/spec/pause/analyzer_spec.rb

@@ -15,9 +15,9 @@ describe Pause::Analyzer do
   let(:configuration) { Pause::Configuration.new }
 
   before do
-    Pause.stub(:config).and_return(configuration)
-    Pause.config.stub(:resolution).and_return(resolution)
-    Pause.config.stub(:history).and_return(history)
+    allow(Pause).to receive(:config).and_return(configuration)
+    allow(Pause.config).to receive(:resolution).and_return(resolution)
+    allow(Pause.config).to receive(:history).and_return(history)
   end
 
   let(:analyzer) { Pause.analyzer }
@@ -27,7 +27,7 @@ describe Pause::Analyzer do
   describe "#analyze" do
     it "checks and blocks if max_allowed is reached" do
       time = Time.now
-      adapter.should_receive(:rate_limit!).once.with(action.key, 12)
+      expect(adapter).to receive(:rate_limit!).once.with(action.scope, '1243123', 12)
       Timecop.freeze time do
         5.times do
           action.increment!
@@ -39,7 +39,7 @@ describe Pause::Analyzer do
 
   describe "#check" do
     it "should return nil if action is NOT blocked" do
-      analyzer.check(action).should be_nil
+      expect(analyzer.check(action)).to be nil
     end
 
     it "should return blocked action if action is blocked" do
@@ -47,7 +47,7 @@ describe Pause::Analyzer do
         5.times do
           action.increment!
         end
-        analyzer.check(action).should be_a(Pause::RateLimitedEvent)
+        expect(analyzer.check(action)).to be_a(Pause::RateLimitedEvent)
       end
     end
   end

data/spec/pause/configuration_spec.rb

@@ -14,12 +14,12 @@ describe Pause::Configuration, "#configure" do
       c.history = 6000
     end
 
-    subject.redis_host.should == "128.23.12.8"
-    subject.redis_port.should == 2134
-    subject.redis_db.should == "13"
+    expect(subject.redis_host).to eq("128.23.12.8")
+    expect(subject.redis_port).to eq(2134)
+    expect(subject.redis_db).to eq("13")
 
-    subject.resolution.should == 5000
-    subject.history.should == 6000
+    expect(subject.resolution).to eq(5000)
+    expect(subject.history).to eq(6000)
   end
 
   it "should provide redis defaults" do
@@ -27,10 +27,10 @@ describe Pause::Configuration, "#configure" do
       # do nothing
     end
 
-    subject.redis_host.should == "127.0.0.1"
-    subject.redis_port.should == 6379
-    subject.redis_db.should == "1"
-    subject.resolution.should == 600 # 10 minutes
-    subject.history.should == 86400 # one day
+    expect(subject.redis_host).to eq("127.0.0.1")
+    expect(subject.redis_port).to eq(6379)
+    expect(subject.redis_db).to eq("1")
+    expect(subject.resolution).to eq(600) # 10 minutes
+    expect(subject.history).to eq(86400) # one day
   end
 end

data/spec/pause/pause_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe Pause do
+  describe 'adapter' do
+    let(:configuration) { Pause::Configuration.new }
+
+    before do
+      Pause.adapter = nil
+      allow(Pause).to receive(:config).and_return(configuration)
+      configuration.configure { |c| c.sharded = sharded }
+    end
+
+    context 'pause is sharded' do
+      let(:sharded) { true }
+
+      it 'is a ShardedAdapter' do
+        expect(Pause.adapter).to be_a(Pause::Redis::ShardedAdapter)
+      end
+    end
+
+    context 'pause is not sharded' do
+      let(:sharded) { false }
+
+      it 'is an Adapter' do
+        expect(Pause.adapter).to be_a(Pause::Redis::Adapter)
+      end
+    end
+  end
+end

data/spec/pause/redis/adapter_spec.rb

@@ -9,9 +9,9 @@ describe Pause::Redis::Adapter do
   let(:configuration) { Pause::Configuration.new }
 
   before do
-    Pause.stub(:config).and_return(configuration)
-    Pause.config.stub(:resolution).and_return(resolution)
-    Pause.config.stub(:history).and_return(history)
+    allow(Pause).to receive(:config).and_return(configuration)
+    allow(Pause.config).to receive(:resolution).and_return(resolution)
+    allow(Pause.config).to receive(:history).and_return(history)
     redis_conn.flushall
   end
 
@@ -19,116 +19,150 @@ describe Pause::Redis::Adapter do
   let(:redis_conn) { adapter.send(:redis) }
 
   describe '#increment' do
-    let(:key) { "213213" }
+    let(:scope) { "blah" }
+    let(:identifier) { "213213" }
+    let(:tracked_key) { "i:blah:|213213|"}
 
     it "should add key to a redis set" do
-      adapter.increment(key, Time.now.to_i)
-      set = redis_conn.zrange(adapter.send(:white_key, key), 0, -1, :with_scores => true)
-      set.should_not be_empty
-      set.size.should eql(1)
-      set[0].size.should eql(2)
+      adapter.increment(scope, identifier, Time.now.to_i)
+      set = redis_conn.zrange(tracked_key, 0, -1, :with_scores => true)
+      expect(set).to_not be_empty
+      expect(set.size).to eql(1)
+      expect(set[0].size).to eql(2)
     end
 
     it "should remove old key from a redis set" do
       time = Time.now
-      redis_conn.should_receive(:zrem).with(adapter.send(:white_key, key), [adapter.period_marker(resolution, time)])
+      expect(redis_conn).to receive(:zrem).with(tracked_key, [adapter.period_marker(resolution, time)])
 
       adapter.time_blocks_to_keep = 1
       Timecop.freeze time do
-        adapter.increment(key, Time.now.to_i)
+        adapter.increment(scope, identifier, Time.now.to_i)
       end
       Timecop.freeze time + (adapter.resolution + 1) do
-        adapter.increment(key, Time.now.to_i)
+        adapter.increment(scope, identifier, Time.now.to_i)
       end
     end
 
     it "sets expiry on key" do
-      redis_conn.should_receive(:expire).with(adapter.send(:white_key, key), history)
-      adapter.increment(key, Time.now.to_i)
+      expect(redis_conn).to receive(:expire).with(tracked_key, history)
+      adapter.increment(scope, identifier, Time.now.to_i)
     end
   end
 
-  describe "#block" do
-    let(:key) { "ipn:follow:123461234" }
-    let(:blocked_key) { "b:#{key}" }
-    let(:ttl) { 110000 }
+  describe '#expire_block_list' do
+    let(:scope) { 'a' }
+    let(:expired_identifier) { '123' }
+    let(:blocked_identifier) { '124' }
+
+    it 'clears all entries with score older than now' do
+      now = Time.now
+
+      Timecop.freeze now - 10 do
+        adapter.rate_limit!(scope, expired_identifier, 5)
+      end
+
+      Timecop.freeze now - 4 do
+        adapter.rate_limit!(scope, blocked_identifier, 5)
+      end
 
-    it "saves ip to redis with expiration" do
-      adapter.rate_limit!(key, ttl)
-      redis_conn.get(blocked_key).should_not be_nil
-      redis_conn.ttl(blocked_key).should == ttl
+      adapter.expire_block_list(scope)
+
+      expect(redis_conn.zscore('b:|a|', blocked_identifier)).not_to be nil
+      expect(redis_conn.zscore('b:|a|', expired_identifier)).to be nil
     end
   end
 
-  describe "#blocked?" do
-    let(:key) { "ipn:follow:123461234" }
+  describe "#rate_limit!" do
+  end
+
+  describe "#rate_limited?" do
+    let(:scope) { 'ipn:follow' }
+    let(:identifier) { '123461234' }
     let(:blocked_key) { "b:#{key}" }
     let(:ttl) { 110000 }
 
     it "should return true if blocked" do
-      adapter.rate_limit!(key, ttl)
-      (!!redis_conn.get(blocked_key).should) == adapter.rate_limited?(key)
+      adapter.rate_limit!(scope, identifier, ttl)
+      expect(adapter.rate_limited?(scope, identifier)).to be true
     end
   end
 
-  describe "#white_key" do
+  describe "#tracked_key" do
     it "prefixes key" do
-      adapter.send(:white_key, "abc").should == "i:abc"
+      expect(adapter.send(:tracked_key, "abc", "12345")).to eq("i:abc:|12345|")
     end
   end
 
   describe '#enable' do
     it 'deletes the disabled flag in redis' do
       adapter.disable("boom")
-      expect(adapter.disabled?("boom")).to be_true
+      expect(adapter.disabled?("boom")).to be true
       adapter.enable("boom")
-      expect(adapter.disabled?("boom")).to be_false
+      expect(adapter.disabled?("boom")).to be false
     end
   end
 
   describe '#disable' do
     it 'sets the disabled flag in redis' do
-      expect(adapter.enabled?("boom")).to be_true
+      expect(adapter.enabled?("boom")).to be true
       adapter.disable("boom")
-      expect(adapter.enabled?("boom")).to be_false
+      expect(adapter.enabled?("boom")).to be false
     end
   end
 
   describe '#rate_limit!' do
     it 'rate limits a key for a specific ttl' do
-      expect(adapter.rate_limited?('1')).to be_false
-      adapter.rate_limit!('1', 10)
-      expect(adapter.rate_limited?('1')).to be_true
+      expect(adapter.rate_limited?('blah', '1')).to be false
+      adapter.rate_limit!('blah', '1', 10)
+      expect(adapter.rate_limited?('blah', '1')).to be true
+    end
+
+    describe 'redis internals' do
+      let(:scope) { 'ipn:follow' }
+      let(:identifier) { '1234' }
+      let(:blocked_key) { "b:|#{scope}|" }
+      let(:ttl) { 110000 }
+
+      it "saves ip to redis with expiration" do
+        time = Time.now
+        Timecop.freeze time do
+          adapter.rate_limit!(scope, identifier, ttl)
+        end
+        expect(redis_conn.zscore(blocked_key, identifier)).to_not be nil
+        expect(redis_conn.zscore(blocked_key, identifier)).to eq(time.to_i + ttl)
+      end
+
     end
   end
 
   describe '#delete_rate_limited_keys' do
     it 'calls redis del with all keys' do
-      adapter.rate_limit!('boom:1', 10)
-      adapter.rate_limit!('boom:2', 10)
+      adapter.rate_limit!('boom', '1', 10)
+      adapter.rate_limit!('boom', '2', 10)
 
-      expect(adapter.rate_limited?('boom:1')).to be_true
-      expect(adapter.rate_limited?('boom:2')).to be_true
+      expect(adapter.rate_limited?('boom', '1')).to be true
+      expect(adapter.rate_limited?('boom', '2')).to be true
 
       adapter.delete_rate_limited_keys('boom')
 
-      expect(adapter.rate_limited?('boom:1')).to be_false
-      expect(adapter.rate_limited?('boom:2')).to be_false
+      expect(adapter.rate_limited?('boom', '1')).to be false
+      expect(adapter.rate_limited?('boom', '2')).to be false
     end
   end
 
   describe '#delete_rate_limit_key' do
     it 'calls redis del with all keys' do
-      adapter.rate_limit!('boom:1', 10)
-      adapter.rate_limit!('boom:2', 10)
+      adapter.rate_limit!('boom', '1', 10)
+      adapter.rate_limit!('boom', '2', 10)
 
-      expect(adapter.rate_limited?('boom:1')).to be_true
-      expect(adapter.rate_limited?('boom:2')).to be_true
+      expect(adapter.rate_limited?('boom', '1')).to be true
+      expect(adapter.rate_limited?('boom', '2')).to be true
 
       adapter.delete_rate_limited_key('boom', '1')
 
-      expect(adapter.rate_limited?('boom:1')).to be_false
-      expect(adapter.rate_limited?('boom:2')).to be_true
+      expect(adapter.rate_limited?('boom', '1')).to be false
+      expect(adapter.rate_limited?('boom', '2')).to be true
     end
   end
 end

data/spec/pause/redis/sharded_adapter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'date'
+require 'timecop'
+
+describe Pause::Redis::ShardedAdapter do
+
+  let(:resolution) { 10 }
+  let(:history) { 60 }
+  let(:configuration) { Pause::Configuration.new }
+
+  before do
+    allow(Pause).to receive(:config).and_return(configuration)
+    allow(Pause.config).to receive(:resolution).and_return(resolution)
+    allow(Pause.config).to receive(:history).and_return(history)
+  end
+
+  let(:adapter) { Pause::Redis::ShardedAdapter.new(Pause.config) }
+
+  describe '#all_keys' do
+    it 'is not supported' do
+      expect { adapter.all_keys('cake') }.to raise_error(Pause::Redis::OperationNotSupported)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -9,10 +9,10 @@ ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
 require 'rubygems'
 require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
 require 'pause'
+require 'pry'
 require 'support/fakeredis'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 

data/spec/support/fakeredis.rb

@@ -1,3 +1,2 @@
-require 'fakeredis'
 require 'fakeredis/rspec'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pause
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Atasay Gokkaya
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2015-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -27,76 +27,6 @@ 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'
-- !ruby/object:Gem::Dependency
-  name: fakeredis
-  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'
-- !ruby/object:Gem::Dependency
-  name: timecop
-  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'
-- !ruby/object:Gem::Dependency
-  name: guard-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'
-- !ruby/object:Gem::Dependency
-  name: rb-fsevent
-  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: Real time rate limiting for multi-process ruby environments based on
   Redis
 email:
@@ -109,7 +39,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".pairs"
 - ".rspec"
 - ".rvmrc"
 - ".travis.yml"
@@ -123,14 +52,18 @@ files:
 - lib/pause/analyzer.rb
 - lib/pause/configuration.rb
 - lib/pause/helper/timing.rb
+- lib/pause/logger.rb
 - lib/pause/rate_limited_event.rb
 - lib/pause/redis/adapter.rb
+- lib/pause/redis/sharded_adapter.rb
 - lib/pause/version.rb
 - pause.gemspec
 - spec/pause/action_spec.rb
 - spec/pause/analyzer_spec.rb
 - spec/pause/configuration_spec.rb
+- spec/pause/pause_spec.rb
 - spec/pause/redis/adapter_spec.rb
+- spec/pause/redis/sharded_adapter_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakeredis.rb
 homepage: https://github.com/wanelo/pause
@@ -152,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: RReal time rate limiting for multi-process ruby environments based on Redis
@@ -160,7 +93,8 @@ test_files:
 - spec/pause/action_spec.rb
 - spec/pause/analyzer_spec.rb
 - spec/pause/configuration_spec.rb
+- spec/pause/pause_spec.rb
 - spec/pause/redis/adapter_spec.rb
+- spec/pause/redis/sharded_adapter_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakeredis.rb
-has_rdoc: 

data/.pairs

@@ -1,13 +0,0 @@
-pairs:
-  ag: Atasay Gokkaya; atasay
-  km: Kaan Meralan; kaan
-  kg: Konstantin Gredeskoul; kig
-  ph: Paul Henry; paul
-  sf: Sean Flannagan; sean
-  es: Eric Saxby; sax
-  tn: Truong Nguyen; constantx
-  cc: Cihan Cimen; cihan
-  sc: Server Cimen; server
-email:
-  prefix: pair
-  domain: wanelo.com