autoscaler 0.7.0 → 0.8.0

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.8.0
+
+- Extracted caching of Heroku worker counts and added experimental Redis cache
+    scaler.counter_cache = Autoscaler::CounterCacheRedis(Sidekiq.method(:redis))
+- Now rescues Heroku::Api::Errors in addition to Excon::Errors
+
 ## 0.7.0
 
 - Added Autoscaler::LinearScalingStrategy

data/README.md

@@ -45,12 +45,20 @@ Install the middleware in your `Sidekiq.configure_` blocks
 
 ## Experimental
 
+### Strategies
+
 You can pass a scaling strategy object instead of the timeout to the server middleware.  The object (or lambda) should respond to `#call(system, idle_time)` and return the desired number of workers.  See `lib/autoscaler/binary_scaling_strategy.rb` for an example.
 
+### Initial Workers
+
 `Client#set_initial_workers` to start workers on main process startup; typically:
 
     Autoscaler::Sidekiq::Client.add_to_chain(chain, 'default' => heroku).set_initial_workers
 
+### Working caching
+
+    scaler.counter_cache = Autoscaler::CounterCacheRedis(Sidekiq.method(:redis))
+
 ## Tests
 
 The project is setup to run RSpec with Guard.  It expects a redis instance on a custom port, which is started by the Guardfile.

data/lib/autoscaler/counter_cache_memory.rb

@@ -0,0 +1,35 @@
+module Autoscaler
+  # Implements a cache for the number of heroku works currently up
+  # Values are stored for short periods in the object
+  class CounterCacheMemory
+    # @param [Numeric] timeout number of seconds to allow before expiration
+    def initialize(timeout = 5)
+      @timeout = timeout
+      @counter = 0
+      @valid_until = Time.now - 1
+    end
+
+    # @param [Numeric] value new counter value
+    def counter=(value)
+      @valid_until = Time.now + @timeout
+      @counter = value
+    end
+
+    # Raised when no block is provided to #counter
+    class Expired < ArgumentError; end
+
+    # Current value.  Uses the Hash#fetch api - pass a block to use in place of expired values or it will raise an exception.
+    def counter
+      return @counter if valid?
+      return yield if block_given?
+      raise Expired
+    end
+
+    private
+    attr_reader :timeout
+
+    def valid?
+      Time.now < @valid_until
+    end
+  end
+end

data/lib/autoscaler/counter_cache_redis.rb

@@ -0,0 +1,44 @@
+module Autoscaler
+  # Implements a cache for the number of heroku works currently up
+  # This permits some web/worker communication, which makes longer timeouts practical.
+  class CounterCacheRedis
+    # @param [Proc, ConnectionPool, Redis client] redis redis interface
+    #   Proc: e.g. Sidekiq.method(:redis)
+    #   ConnectionPool: e.g. what you pass to Sidekiq.redis=
+    #   Redis client: e.g. Redis.connect
+    # @param [Numeric] timeout number of seconds to allow before expiration
+    def initialize(redis, timeout = 5 * 60)
+      @redis = redis
+      @timeout = timeout
+    end
+
+    # @param [Numeric] value new counter value
+    def counter=(value)
+      redis {|c| c.setex('autoscaler:workers', @timeout, value)}
+    end
+
+    # Raised when no block is provided to #counter
+    class Expired < ArgumentError; end
+
+    # Current value.  Uses the Hash#fetch api - pass a block to use in place of expired values or it will raise an exception.
+    def counter
+      value = redis {|c| c.get('autoscaler:workers')}
+      return value.to_i if value
+      return yield if block_given?
+      raise Expired
+    end
+
+    private
+    attr_reader :timeout
+
+    def redis(&block)
+      if @redis.respond_to?(:call)
+        @redis.call(&block)
+      elsif @redis.respond_to?(:with)
+        @redis.with(&block)
+      else
+        block.call(@redis)
+      end
+    end
+  end
+end

data/lib/autoscaler/heroku_scaler.rb

@@ -1,4 +1,5 @@
 require 'heroku-api'
+require 'autoscaler/counter_cache_memory'
 
 module Autoscaler
   # Wraps the Heroku API to provide just the interface that we need for scaling.
@@ -13,8 +14,7 @@ module Autoscaler
       @client = Heroku::API.new(:api_key => key)
       @type = type
       @app = app
-      @workers = 0
-      @known = Time.now - 1
+      @workers = CounterCacheMemory.new
     end
 
     attr_reader :app
@@ -23,25 +23,22 @@ module Autoscaler
     # Read the current worker count (value may be cached)
     # @return [Numeric] number of workers
     def workers
-      if known?
-        @workers
-      else
-        know heroku_get_workers
-      end
+      @workers.counter {@workers.counter = heroku_get_workers}
     end
 
     # Set the number of workers (noop if workers the same)
     # @param [Numeric] n number of workers
     def workers=(n)
-      if n != @workers || !known?
+      unknown = false
+      current = @workers.counter{unknown = true; 1}
+      if n != current || unknown
         p "Scaling #{type} to #{n}"
         heroku_set_workers(n)
-        know n
+        @workers.counter = n
       end
     end
 
-    # Callable object which responds to exceptions during api calls
-    #
+    # Callable object which responds to exceptions during api calls #
     # @example
     #   heroku.exception_handler = lambda {|exception| MyApp.logger.error(exception)}
     #   heroku.exception_handler = lambda {|exception| raise}
@@ -52,28 +49,25 @@ module Autoscaler
     #   }
     attr_writer :exception_handler
 
-    private
-    attr_reader :client
-
-    def know(n)
-      @known = Time.now + 5
-      @workers = n
+    # Object which supports #counter and #counter=
+    # Defaults to CounterCacheMemory
+    def counter_cache=(cache)
+      @workers = cache
     end
 
-    def known?
-      Time.now < @known
-    end
+    private
+    attr_reader :client
 
     def heroku_get_workers
       client.get_ps(app).body.count {|ps| ps['process'].match /#{type}\.\d?/ }
-    rescue Excon::Errors::Error => e
+    rescue Excon::Errors::Error, Heroku::API::Errors::Error => e
       exception_handler.call(e)
-      @workers
+      0
     end
 
     def heroku_set_workers(n)
       client.post_ps_scale(app, type, n)
-    rescue Excon::Errors::Error => e
+    rescue Excon::Errors::Error, Heroku::API::Errors::Error => e
       exception_handler.call(e)
     end
 

data/lib/autoscaler/version.rb

@@ -1,4 +1,4 @@
 module Autoscaler
   # version number
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/spec/autoscaler/counter_cache_memory_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'autoscaler/counter_cache_memory'
+
+describe Autoscaler::CounterCacheMemory do
+  let(:cut) {Autoscaler::CounterCacheMemory}
+
+  it {expect{cut.new.counter}.to raise_error(cut::Expired)}
+  it {cut.new.counter{1}.should == 1}
+
+  it 'set and store' do
+    cache = cut.new
+    cache.counter = 1
+    cache.counter.should == 1
+  end
+
+  it 'times out' do
+    cache = cut.new(0)
+    cache.counter = 1
+    expect{cache.counter.should}.to raise_error(cut::Expired)
+  end
+end

data/spec/autoscaler/counter_cache_redis_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'autoscaler/counter_cache_redis'
+
+describe Autoscaler::CounterCacheRedis do
+  before do
+    @redis = Sidekiq.redis = REDIS
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  let(:cut) {Autoscaler::CounterCacheRedis}
+  subject {cut.new(Sidekiq.method(:redis))}
+
+  it {expect{subject.counter}.to raise_error(cut::Expired)}
+  it {subject.counter{1}.should == 1}
+
+  it 'set and store' do
+    subject.counter = 2
+    subject.counter.should == 2
+  end
+
+  it 'times out' do
+    cache = cut.new(Sidekiq.method(:redis), 1) # timeout 0 invalid
+    cache.counter = 3
+    sleep(2)
+    expect{cache.counter}.to raise_error(cut::Expired)
+  end
+
+  it 'passed a connection pool' do
+    cache = cut.new(@redis)
+    cache.counter = 4
+    cache.counter.should == 4
+  end
+
+  it 'passed a plain connection' do
+    connection = Redis.connect(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+    cache = cut.new connection
+    cache.counter = 5
+    cache.counter.should == 5
+  end
+end

data/spec/autoscaler/heroku_scaler_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'autoscaler/heroku_scaler'
+require 'heroku/api/errors'
 
 describe Autoscaler::HerokuScaler, :online => true do
   let(:cut) {Autoscaler::HerokuScaler}
@@ -18,17 +19,17 @@ describe Autoscaler::HerokuScaler, :online => true do
     its(:workers) {should == 1}
   end
 
-  describe 'exception handling', :focus => true do
+  shared_examples 'exception handler' do |exception_class|
     before do
-      def client.client
-        raise Excon::Errors::SocketError.new(Exception.new('oops'))
-      end
+      client.should_receive(:client){
+        raise exception_class.new(Exception.new('oops'))
+      }
     end
 
     describe "default handler" do
       it {expect{client.workers}.to_not raise_error}
       it {client.workers.should == 0}
-      it {expect{client.workers = 1}.to_not raise_error}
+      it {expect{client.workers = 2}.to_not raise_error}
     end
 
     describe "custom handler" do
@@ -40,4 +41,9 @@ describe Autoscaler::HerokuScaler, :online => true do
       it {client.workers; @caught.should be_true}
     end
   end
-end
+
+  describe 'exception handling', :focus => true do
+    it_behaves_like 'exception handler', Excon::Errors::SocketError
+    it_behaves_like 'exception handler', Heroku::API::Errors::Error
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: autoscaler
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-18 00:00:00.000000000 Z
+date: 2014-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -119,6 +119,8 @@ files:
 - CHANGELOG.md
 - README.md
 - lib/autoscaler/binary_scaling_strategy.rb
+- lib/autoscaler/counter_cache_memory.rb
+- lib/autoscaler/counter_cache_redis.rb
 - lib/autoscaler/delayed_shutdown.rb
 - lib/autoscaler/heroku_scaler.rb
 - lib/autoscaler/linear_scaling_strategy.rb
@@ -138,6 +140,8 @@ files:
 - examples/simple.rb
 - Guardfile
 - spec/autoscaler/binary_scaling_strategy_spec.rb
+- spec/autoscaler/counter_cache_memory_spec.rb
+- spec/autoscaler/counter_cache_redis_spec.rb
 - spec/autoscaler/delayed_shutdown_spec.rb
 - spec/autoscaler/heroku_scaler_spec.rb
 - spec/autoscaler/linear_scaling_strategy_spec.rb
@@ -177,6 +181,8 @@ summary: Start/stop Sidekiq workers on Heroku
 test_files:
 - Guardfile
 - spec/autoscaler/binary_scaling_strategy_spec.rb
+- spec/autoscaler/counter_cache_memory_spec.rb
+- spec/autoscaler/counter_cache_redis_spec.rb
 - spec/autoscaler/delayed_shutdown_spec.rb
 - spec/autoscaler/heroku_scaler_spec.rb
 - spec/autoscaler/linear_scaling_strategy_spec.rb