heroku-scalr 0.1.0 → 0.2.0

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/heroku-scalr.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.name        = File.basename(__FILE__, '.gemspec')
   s.summary     = "Watch and scale your dynos!"
   s.description = "Issues recurring 'pings' to your Heroku apps and scales dynos up or down depending on pre-defined rules"
-  s.version     = "0.1.0"
+  s.version     = "0.2.0"
 
   s.authors     = ["Black Square Media"]
   s.email       = "info@blacksquaremedia.com"

data/lib/heroku/scalr/app.rb

@@ -6,11 +6,15 @@ class Heroku::Scalr::App
     max_dynos: 2,
     wait_low: 10,
     wait_high: 100,
+    ping_low: 200,
+    ping_high: 500,
+    metric: :ping,
     min_frequency: 60
   }.freeze
 
   attr_reader :name, :http, :api, :interval, :min_dynos, :max_dynos,
-              :wait_low, :wait_high, :min_frequency, :last_scaled_at
+              :metric, :wait_low, :wait_high, :ping_low, :ping_high,
+              :min_frequency, :last_scaled_at
 
   # @param [String] name Heroku app name
   # @param [Hash] opts options
@@ -45,6 +49,9 @@ class Heroku::Scalr::App
     @max_dynos = opts[:max_dynos].to_i
     @wait_low  = opts[:wait_low].to_i
     @wait_high = opts[:wait_high].to_i
+    @ping_low  = opts[:ping_low].to_i
+    @ping_high = opts[:ping_high].to_i
+    @metric    = Heroku::Scalr::Metric.new(opts[:metric], self)
     @min_frequency  = opts[:min_frequency].to_i
     @last_scaled_at = Time.at(0)
   end
@@ -57,20 +64,7 @@ class Heroku::Scalr::App
       return
     end
 
-    wait = http.get.headers["X-Heroku-Queue-Wait"]
-    unless wait
-      log :warn, "unable to determine queue wait time"
-      return
-    end
-
-    wait = wait.to_i
-    log :debug, "current queue wait time: #{wait}ms"
-
-    if wait <= wait_low
-      do_scale(-1)
-    elsif wait >= wait_high
-      do_scale(1)
-    end
+    do_scale(metric.by)
   end
 
   # @param [Symbol] level
@@ -81,12 +75,15 @@ class Heroku::Scalr::App
 
   protected
 
+
     # @return [Time] the next scale attempt
     def next_scale_attempt
       last_scaled_at + min_frequency
     end
 
     def do_scale(by)
+      return if by.zero?
+
       info = api.get_app(name)
       unless info.status == 200
         log :warn, "error fetching app info, responded with #{info.status}"

data/lib/heroku/scalr/metric.rb

@@ -0,0 +1,81 @@
+module Heroku::Scalr::Metric
+
+  # @param [Symbol] type the metric type
+  # @param [Heroku::Scalr::App] app the application
+  # @return [Heroku::Scalr::Metric::Abstract] a metric instance
+  def self.new(type, app)
+    case type
+    when :wait, "wait"
+      Wait.new(app)
+    else
+      Ping.new(app)
+    end
+  end
+
+  class Abstract
+
+    # @param [Heroku::Scalr::App] app the application
+    def initialize(app)
+      @app = app
+    end
+
+    # @return [Integer] number of dynos to adjust by
+    def by
+      0
+    end
+
+    protected
+
+      def compare(ms, low, high)
+        ms <= low ? -1 : (ms >= high ? 1 : 0)
+      end
+
+      def log(*args)
+        @app.log(*args)
+      end
+
+  end
+
+  class Ping < Abstract
+
+    # @see Heroku::Scalr::Metric::Abstract#by
+    def by
+      status = nil
+
+      real = Benchmark.realtime do
+        status = @app.http.get.status
+      end
+
+      unless status == 200
+        log :warn, "unable to ping, server responded with #{status}"
+        return 0
+      end
+
+      ms = (real * 1000).floor
+      log :debug, "current ping time: #{ms}ms"
+
+      compare(ms, @app.ping_low, @app.ping_high)
+    end
+
+  end
+
+  class Wait < Abstract
+
+    # @see Heroku::Scalr::Metric::Abstract#by
+    def by
+      ms = @app.http.get.headers["X-Heroku-Queue-Wait"]
+      unless ms
+        log :warn, "unable to determine queue wait time"
+        return 0
+      end
+
+      ms = ms.to_i
+      log :debug, "current queue wait time: #{ms}ms"
+
+      compare(ms, @app.wait_low, @app.wait_high)
+    end
+
+  end
+
+
+end

data/lib/heroku/scalr.rb

@@ -2,6 +2,7 @@ require 'heroku/api'
 require 'logger'
 require 'excon'
 require 'timers'
+require 'benchmark'
 
 module Heroku::Scalr
   extend self
@@ -27,6 +28,6 @@ module Heroku::Scalr
 
 end
 
-%w|config app runner|.each do |name|
+%w|config app runner metric|.each do |name|
   require "heroku/scalr/#{name}"
 end

data/spec/heroku/scalr/app_spec.rb

@@ -2,21 +2,24 @@ require 'spec_helper'
 
 describe Heroku::Scalr::App do
 
-  subject    { described_class.new('name', api_key: 'key') }
+  subject    { described_class.new('name', api_key: 'key', max_dynos: 3) }
 
   def mock_response(status, body)
     mock "APIResponse", status: status, headers: {}, body: body
   end
 
-  its(:name)            { should == 'name' }  
+  its(:name)            { should == 'name' }
   its(:http)            { should be_instance_of(Excon::Connection) }
   its(:api)             { should be_instance_of(Heroku::API) }
+  its(:metric)          { should be_instance_of(Heroku::Scalr::Metric::Ping) }
 
   its(:interval)        { should be(30) }
   its(:min_dynos)       { should be(1) }
-  its(:max_dynos)       { should be(2) }
+  its(:max_dynos)       { should be(3) }
   its(:wait_low)        { should be(10) }
   its(:wait_high)       { should be(100) }
+  its(:ping_low)        { should be(200) }
+  its(:ping_high)       { should be(500) }
   its(:min_frequency)   { should be(60) }
   its(:last_scaled_at)  { should == Time.at(0)}
 
@@ -39,66 +42,63 @@ describe Heroku::Scalr::App do
     end
   end
 
-  describe "scale!" do
+  describe "scaling" do
+    before do
+      subject.api.stub get_app: mock_response(200, { "dynos" => 2 }), put_dynos: mock_response(200, "")
+      subject.metric.stub by: -1
+    end
 
-    context "when low wait time" do
-      before do
-        subject.api.stub get_app: mock_response(200, { "dynos" => 2 }), put_dynos: mock_response(200, "")
-      end
+    it "should skip if scaled too recently" do
+      subject.instance_variable_set :@last_scaled_at, Time.now
+      subject.scale!.should be_nil
+    end
 
-      let! :app_request do
-        stub_request(:get, "http://name.herokuapp.com/robots.txt").        
-          to_return(body: "", headers: { "X-Heroku-Queue-Wait" => 3 })
-      end
+    it "should determine scale through metric" do
+      subject.metric.should_receive(:by).and_return(-1)
+      subject.scale!.should == 1
+    end
 
-      it "should skip if scaled too recently" do
-        subject.instance_variable_set :@last_scaled_at, Time.now
-        subject.scale!.should be_nil
-      end
+    it "should skip when there is no need" do
+      subject.metric.should_receive(:by).and_return(0)
+      subject.scale!.should be_nil
+    end
 
-      it "should query the queue wait time from the app" do
-        subject.scale!.should == 1
-        app_request.should have_been_made
-      end
-      
-      it "should check current number of dynos" do
-        subject.api.should_receive(:get_app).with("name").and_return mock_response(200, { "dynos" => 2 })
-        subject.scale!.should == 1
-      end
+    it "should check current number of dynos" do
+      subject.api.should_receive(:get_app).with("name").and_return mock_response(200, { "dynos" => 2 })
+      subject.scale!.should == 1
+    end
+
+    context "down" do
 
-      it "should update dynos" do
+      it "should return the new number of dynos" do
         subject.api.should_receive(:put_dynos).with("name", 1).and_return mock_response(200, "")
         subject.scale!.should == 1
       end
 
-      it "should not scale down if min number of dynos is reached" do
+      it "should skip if min number of dynos reached" do
         subject.api.should_receive(:get_app).with("name").and_return mock_response(200, { "dynos" => 1 })
         subject.api.should_not_receive(:put_dynos)
         subject.scale!.should be_nil
       end
+
     end
 
-    context "when high wait time" do
-      before do
-        subject.api.stub get_app: mock_response(200, { "dynos" => 1 }), put_dynos: mock_response(200, "")
-      end
+    context "up" do
 
-      let! :app_request do
-        stub_request(:get, "http://name.herokuapp.com/robots.txt").        
-          to_return(body: "", headers: { "X-Heroku-Queue-Wait" => 101 })
-      end
+      before { subject.metric.stub by: 1 }
 
-      it "should update dynos" do
-        subject.api.should_receive(:get_app).with("name").and_return mock_response(200, { "dynos" => 1 })
-        subject.scale!.should == 2
+      it "should return the new number of dynos" do
+        subject.api.should_receive(:put_dynos).with("name", 3).and_return mock_response(200, "")
+        subject.scale!.should == 3
       end
 
-      it "should not scale up if max number of dynos is reached" do
-        subject.api.should_receive(:get_app).with("name").and_return mock_response(200, { "dynos" => 2 })
+      it "should skip if max number of dynos reached" do
+        subject.api.should_receive(:get_app).with("name").and_return mock_response(200, { "dynos" => 3 })
         subject.api.should_not_receive(:put_dynos)
         subject.scale!.should be_nil
       end
+
     end
-  end
 
+  end
 end

data/spec/heroku/scalr/metric_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Heroku::Scalr::Metric do
+
+  let(:app) { Heroku::Scalr::App.new('name', api_key: 'key') }
+
+  it 'should create metric instances' do
+    described_class.new(:wait, app).should be_instance_of(described_class::Wait)
+    described_class.new("wait", app).should be_instance_of(described_class::Wait)
+    described_class.new(:ping, app).should be_instance_of(described_class::Ping)
+    described_class.new(:any, app).should be_instance_of(described_class::Ping)
+  end
+
+end
+
+describe Heroku::Scalr::Metric::Abstract do
+
+  let(:app) { Heroku::Scalr::App.new('name', api_key: 'key') }
+  subject   { described_class.new(app) }
+  its(:by)  { should == 0 }
+
+end
+
+describe Heroku::Scalr::Metric::Ping do
+
+  let(:app)           { Heroku::Scalr::App.new('name', api_key: 'key') }
+  let(:ping_time)     { 0.250 }
+  let!(:http_request) { stub_request(:get, "http://name.herokuapp.com/robots.txt") }
+
+  subject   { described_class.new(app) }
+  before    { Benchmark.stub(:realtime).and_yield.and_return(ping_time) }
+
+  describe "low ping time" do
+    let(:ping_time) { 0.150 }
+
+    it 'should scale down' do
+      subject.by.should == -1
+      http_request.should have_been_made
+    end
+  end
+
+  describe "high ping time" do
+    let(:ping_time) { 0.550 }
+
+    it 'should scale up' do
+      subject.by.should == 1
+      http_request.should have_been_made
+    end
+  end
+
+  describe "normal ping time" do
+    it 'should not scale' do
+      subject.by.should == 0
+      http_request.should have_been_made
+    end
+  end
+
+  describe "failed requests" do
+
+    let! :http_request do
+      stub_request(:get, "http://name.herokuapp.com/robots.txt").to_return(status: 404)
+    end
+
+    it 'should not scale' do
+      Heroku::Scalr.logger.should_receive(:warn)
+      subject.by.should == 0
+      http_request.should have_been_made
+    end
+
+  end
+
+end
+
+describe Heroku::Scalr::Metric::Wait do
+
+  let(:app) { Heroku::Scalr::App.new('name', api_key: 'key') }
+  subject   { described_class.new(app) }
+
+  describe "low queue wait time" do
+
+    let! :http_request do
+      stub_request(:get, "http://name.herokuapp.com/robots.txt").to_return(body: "", headers: { "X-Heroku-Queue-Wait" => 3 })
+    end
+
+    it 'should scale down' do
+      subject.by.should == -1
+      http_request.should have_been_made
+    end
+
+  end
+
+  describe "high queue wait time" do
+
+    let! :http_request do
+      stub_request(:get, "http://name.herokuapp.com/robots.txt").to_return(body: "", headers: { "X-Heroku-Queue-Wait" => 300 })
+    end
+
+    it 'should scale up' do
+      subject.by.should == 1
+      http_request.should have_been_made
+    end
+
+  end
+
+  describe "normal queue wait time" do
+
+    let! :http_request do
+      stub_request(:get, "http://name.herokuapp.com/robots.txt").to_return(body: "", headers: { "X-Heroku-Queue-Wait" => 20 })
+    end
+
+    it 'should not scale' do
+      subject.by.should == 0
+      http_request.should have_been_made
+    end
+
+  end
+
+  describe "queue wait unretrievable" do
+
+    let! :http_request do
+      stub_request(:get, "http://name.herokuapp.com/robots.txt")
+    end
+
+    it 'should not scale' do
+      Heroku::Scalr.logger.should_receive(:warn)
+      subject.by.should == 0
+      http_request.should have_been_made
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heroku-scalr
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-14 00:00:00.000000000 Z
+date: 2013-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
@@ -131,6 +131,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
 - .travis.yml
 - Gemfile
 - Gemfile.lock
@@ -141,10 +142,12 @@ files:
 - lib/heroku/scalr/app.rb
 - lib/heroku/scalr/cli.rb
 - lib/heroku/scalr/config.rb
+- lib/heroku/scalr/metric.rb
 - lib/heroku/scalr/runner.rb
 - spec/fixtures/config_a.rb
 - spec/heroku/scalr/app_spec.rb
 - spec/heroku/scalr/config_spec.rb
+- spec/heroku/scalr/metric_spec.rb
 - spec/heroku/scalr/runner_spec.rb
 - spec/heroku/scalr_spec.rb
 - spec/spec_helper.rb