heroku-vector 0.0.2

data/examples/upstart_conf

@@ -0,0 +1,10 @@
+# Example Upstart config to run heroku_vector on Linux
+# eg: /etc/init/heroku-vector.conf
+
+respawn
+respawn limit 15 5
+
+start on runlevel [2345]
+stop on runlevel [06]
+
+exec /usr/local/bin/heroku_vector -c /path/to/your/config.rb -l /var/log/heroku_vector.log

data/heroku-vector.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'heroku_vector/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "heroku-vector"
+  spec.version       = HerokuVector::VERSION
+  spec.authors       = ["Winfield Peterson"]
+  spec.email         = ["winfield.peterson@gmail.com"]
+  spec.summary       = %q{Sampling Auto-scaler for Heroku dynos}
+  spec.description   = %q{Linearly scale Heroku dyno counts based on sampled metrics}
+  spec.homepage      = "https://github.com/wpeterson/heroku-vector"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activeresource"
+  spec.add_dependency "heroku-api"
+  spec.add_dependency "newrelic_api"
+  spec.add_dependency "redis"
+  spec.add_dependency "redis-namespace"
+  spec.add_dependency "sidekiq"
+  spec.add_dependency "dotenv"
+  spec.add_dependency "eventmachine"
+
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "pry"
+end

data/lib/heroku_vector.rb

@@ -0,0 +1,133 @@
+module HerokuVector
+  module Engine
+  end
+  module Source
+  end
+end
+
+require 'logger'
+
+require 'heroku_vector/helper'
+
+require 'heroku_vector/dyno_scaler'
+require 'heroku_vector/process_manager'
+require 'heroku_vector/sampler'
+require 'heroku_vector/worker'
+require 'heroku_vector/version'
+require 'heroku_vector/engine/heroku'
+require 'heroku_vector/source/new_relic'
+require 'heroku_vector/source/sidekiq'
+
+module HerokuVector
+  class << self
+
+    def default_logger
+      return options[:logger] if options[:logger]
+
+      logger = Logger.new(STDOUT)
+      logger.level = options[:log_level]
+      logger.formatter = proc do |severity, time, program_name, message|
+        "#{time.utc.iso8601(3)} #{severity}: #{message}\n"
+      end
+
+      logger
+    end
+
+    def options
+      @options ||= DEFAULTS.dup
+    end
+
+    def options=(opts)
+      @options = opts
+    end
+
+    def configure
+      yield self if block_given?
+    end
+
+    def logger
+      @logger ||= default_logger
+    end
+
+    def logger=(log)
+      @logger = log
+    end
+
+    def engine
+      @engine ||= options[:engine]
+    end
+
+    def engine=(engine)
+      @engine = engine
+    end
+
+    def dyno_scalers
+      @dyno_scalers ||= {}
+    end
+
+    def dyno_scalers=(dyno_scalers)
+      @dyno_scalers = dyno_scalers
+    end
+
+    def add_dyno_scaler(name, options={})
+      dyno_scalers[name] = options
+    end
+
+    def min_scale_time_secs
+      @min_scale_time_secs ||= options[:min_scale_time_secs]
+    end
+
+    def min_scale_time_secs=(time_secs)
+      @min_scale_time_secs = time_secs
+    end
+
+    def heroku_app_name
+      @heroku_app_name ||= ENV['HEROKU_APP_NAME']
+    end
+
+    def heroku_app_name=(app_name)
+      @heroku_app_name = app_name
+    end
+
+    def newrelic_api_key
+      @newrelic_api_key ||= ENV['NEWRELIC_API_KEY']
+    end
+
+    def newrelic_api_key=(api_key)
+      @newrelic_api_key = api_key
+    end
+
+    def newrelic_account_id
+      @newrelic_account_id ||= ENV['NEWRELIC_ACCOUNT_ID']
+    end
+
+    def newrelic_account_id=(account_id)
+      @newrelic_account_id = account_id
+    end
+
+    def newrelic_app_id
+      @newrelic_app_id ||= ENV['NEWRELIC_APP_ID']
+    end
+
+    def newrelic_app_id=(app_id)
+      @newrelic_app_id = app_id
+    end
+
+    def sidekiq_redis_url
+      ENV['REDIS_URL'] || 'redis://127.0.0.1/0'
+    end
+
+    def sidekiq_redis_namespace
+      ENV['SIDEKIQ_REDIS_NAMESPACE']
+    end
+  end
+end
+
+module HerokuVector
+  DEFAULTS = {
+    :min_scale_time_secs => 5 * 60, # 5 mins
+    :log_level => Logger::INFO,
+    :engine => Engine::Heroku.new
+  }
+
+end

data/lib/heroku_vector/dyno_scaler.rb

@@ -0,0 +1,133 @@
+module HerokuVector
+  class DynoScaler
+    include HerokuVector::Helper
+
+    MIN_SCALE_TIME_DELTA_SEC = 5 * 60 # 5 mins
+
+    attr_accessor :source, :last_scale_time
+    attr_reader :name,
+      :sampler, :period, :min_value, :max_value,
+      :min_dynos, :max_dynos,
+      :engine, :scale_up_by, :scale_down_by
+
+    def initialize(name, options={})
+      @name = name
+      @period = options[:period] || 60 # 1 min
+      sample_size = options[:sample_size] || Sampler.capacity_for_sample_period(@period)
+      @sampler = Sampler.new( sample_size )
+      @min_dynos = options[:min_dynos] || 2
+      @max_dynos = options[:max_dynos] || 10
+      @min_value = options[:min_value] || raise("DynoScaler: min_value required")
+      @max_value = options[:max_value] || raise("DynoScaler: max_value required")
+
+      @scale_up_by = options[:scale_up_by] || 1
+      @scale_down_by = options[:scale_down_by] || 1
+      @source = load_data_source(options)
+      @engine = options[:engine] || Engine::Heroku.new
+    end
+
+    def load_data_source(options)
+      source = options[:source]
+
+      if source.is_a?(Class)
+        @source = source.new(options)
+      else
+        begin
+          clazz = HerokuVector::Source.const_get(source)
+          @source = clazz.new(options)
+        rescue
+          raise "DynoScaler: Invalid source class '#{source}'"
+        end
+      end
+    end
+
+    def reset
+      sampler.clear
+      @last_scale_time = nil
+    end
+
+    def run
+      begin
+        collect_sample
+        return unless enough_samples?
+        return if scaling_too_soon?
+
+        evaluate_and_scale
+      rescue => e
+        logger.error "#{self.name} worker.run(): #{e}"
+      end
+    end
+
+    def evaluate_and_scale
+      num_dynos = current_size
+      total_min = min_value * num_dynos
+      total_max = max_value * num_dynos
+      value = current_value
+
+      logger.debug "#{self.name}: #{num_dynos} dynos - #{value} #{display_unit}"
+      if value < total_min
+        unless num_dynos <= min_dynos
+          logger.info "#{self.name}: #{num_dynos} dynos - #{value} #{display_unit} below #{total_min} - scaling down"
+        end
+        # Always scale down one at a time
+        new_amount = num_dynos - scale_down_by
+        scale_dynos(num_dynos, new_amount)
+      elsif value > total_max
+        unless num_dynos >= max_dynos
+          logger.info "#{self.name}: #{num_dynos} dynos - #{value} #{display_unit} above #{total_max} - scaling up"
+        end
+        # Scale up to N new dynos
+        new_amount = num_dynos + scale_up_by
+        scale_dynos(num_dynos, new_amount)
+      end
+    end
+
+    def current_value
+      sampler.mean
+    end
+
+    def collect_sample
+      sampler << source.sample
+    end
+
+    def current_size
+      engine.count_for_dyno_name(self.name)
+    end
+
+    def scale_dynos(current_amount, new_amount)
+      new_amount = normalize_dyno_increment(new_amount)
+      return if current_amount == new_amount
+
+      record_last_scale_event
+
+      engine.scale_dynos(self.name, new_amount)
+    end
+
+    def normalize_dyno_increment(amount)
+      [
+        [amount, max_dynos].min,
+        min_dynos
+      ].max
+    end
+
+    def record_last_scale_event
+      @last_scale_time = Time.now
+    end
+
+    def enough_samples?
+      sampler.full?
+    end
+
+    def scaling_too_soon?
+      return false unless last_scale_time
+      scale_delta = Time.now - last_scale_time
+
+      MIN_SCALE_TIME_DELTA_SEC >= scale_delta
+    end
+
+    def display_unit
+      source.unit rescue 'units'
+    end
+
+  end
+end

data/lib/heroku_vector/engine/heroku.rb

@@ -0,0 +1,63 @@
+require 'heroku-api'
+
+module HerokuVector::Engine
+  class Heroku
+    include HerokuVector::Helper
+
+    CacheEntry = Struct.new(:data, :expires_at)
+
+    attr_accessor :app, :heroku
+
+    def initialize(options={})
+      options = { app: HerokuVector.heroku_app_name }.merge(options)
+
+      @app = options[:app]
+      @heroku = ::Heroku::API.new
+    end
+
+    def get_dynos_by_name_cached
+      if @dynos_by_name && @dynos_by_name.expires_at > Time.now
+        return @dynos_by_name.data
+      end
+
+      @dynos_by_name = begin
+        expires_at = Time.now + 60 # 1 min from now
+        CacheEntry.new(get_dynos_by_name, expires_at)
+      rescue
+        nil
+      end
+      @dynos_by_name.data
+    end
+
+    def get_dynos_by_name
+      dyno_types = get_dyno_types
+      dyno_types.index_by {|dyno| dyno["name"] }
+    end
+
+    def get_dyno_types
+      response = heroku.get_dyno_types(app)
+      assert_heroku_api_success(response)
+      response.body
+    end
+
+    def count_for_dyno_name(dyno_name)
+      dyno = get_dynos_by_name_cached[dyno_name]
+      return 0 unless dyno
+
+      dyno['quantity'] || 0
+    end
+
+    def scale_dynos(dyno_name, count)
+      response = heroku.post_ps_scale(app, dyno_name, count)
+      assert_heroku_api_success(response)
+      logger.info "Heroku.scale_dynos(#{dyno_name}, #{count})"
+
+      response.body
+    end
+
+    def assert_heroku_api_success(response)
+      raise 'Invalid Heroku API Response' unless response
+      raise "Error #{response.status} from Heroku API" unless response.status == 200
+    end
+  end
+end

data/lib/heroku_vector/helper.rb

@@ -0,0 +1,23 @@
+
+module HerokuVector
+  module Helper
+    def self.included(target)
+      target.send(:include, InstanceMethods)
+      target.extend ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      def logger
+        HerokuVector.logger
+      end
+
+      def round_to_one_decimal(value)
+        ((value * 10.0).floor.to_f / 10.0)
+      end
+
+    end
+  end
+end

data/lib/heroku_vector/process_manager.rb

@@ -0,0 +1,61 @@
+
+module HerokuVector
+  class ProcessManager
+    include HerokuVector::Helper
+
+    attr_accessor :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def start
+      daemonize           if options[:daemonize]
+      redirect_to_logfile if options[:logfile]
+      write_pid
+
+      worker = Worker.new(options)
+      worker.run
+    end
+
+    def daemonize
+      return unless options[:daemonize]
+
+      raise ArgumentError, "Daemonized mode requires a logfile" unless options[:logfile]
+      files_to_reopen = []
+      ObjectSpace.each_object(File) do |file|
+        files_to_reopen << file unless file.closed?
+      end
+
+      ::Process.daemon(true, true)
+
+      files_to_reopen.each do |file|
+        begin
+          file.reopen file.path, "a+"
+          file.sync = true
+        rescue ::Exception
+        end
+      end
+    end
+
+    def redirect_to_logfile
+      [$stdout, $stderr].each do |io|
+        File.open(options[:logfile], 'ab') do |f|
+          io.reopen(f)
+        end
+        io.sync = true
+      end
+    end
+
+    def write_pid
+      return unless path = options[:pidfile]
+
+      pidfile = File.expand_path(path)
+      logger.info "Writing pidfile #{pidfile}"
+      File.open(pidfile, 'w') do |f|
+        f.puts ::Process.pid
+      end
+    end
+
+  end
+end