hipstascale 0.1.0

data/lib/hipsta_scale/application.rb

@@ -0,0 +1,96 @@
+module HipstaScale
+  class Application
+    attr_reader :name
+    
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block) if block_given?
+    end
+    
+    # We take what NewRelic returns us and add an extra 20% to it base on the
+    # recommendation of this blog post:
+    # http://engineering.viki.com/2011/08/10/autoscaling-heroku-dynos/
+    def current_load
+      (new_relic.busy_percent + 20.0) / 100
+    end
+    
+    def heroku_key(key=nil)
+      @heroku_key = key unless key.nil?
+      @heroku_key || HipstaScale.heroku_key
+    end
+    
+    def heroku_ps(name=nil)
+      @heroku_ps = name unless name.nil?
+      @heroku_ps || HipstaScale.heroku_ps
+    end
+    
+    def interval(interval=nil)
+      @interval = interval unless interval.nil?
+      @interval || HipstaScale.interval
+    end
+    
+    def load_limit(load=nil)
+      @load_limit = load unless load.nil?
+      @load_limit || HipstaScale.load_limit
+    end
+    
+    def minimum_processes(minimum=nil)
+      @minimum_processes = minimum unless minimum.nil?
+      @minimum_processes || HipstaScale.minimum_processes
+    end
+    alias_method :minimum_processes, :minimum_process
+    
+    def new_relic_id(id=nil)
+      @new_relic_id = id unless id.nil?
+      @new_relic_id
+    end
+    
+    def new_relic_key(key=nil)
+      @new_relic_key = key unless key.nil?
+      @new_relic_key || HipstaScale.new_relic_key
+    end
+    
+    def processes_running
+      heroku.processes.count
+    end
+    
+    def processes_needed
+      processes = ((processes_running * current_load) / load_limit).ceil
+      processes = minimum_processes if processes < minimum_processes
+      processes = maximum_processes if processes > maximum_processes
+      processes
+    end
+    
+    def scale(count)
+      heroku
+    end
+    
+    def scale!
+      scale(processes_needed)
+    end
+    
+    def tick(&block)
+      block.call
+      expire!
+    end
+    
+    private
+    
+    def expire!
+      heroku.expire!
+      new_relic.expire!
+    end
+    
+    def heroku
+      @_heroku ||= Heroku.new(self)
+    end
+    
+    def maximum_processes
+      100
+    end
+    
+    def new_relic
+      @_new_relic ||= NewRelic.new(self)
+    end
+  end
+end

data/lib/hipsta_scale/base.rb

@@ -0,0 +1,38 @@
+module HipstaScale
+  module Base
+    def app(name, &block)
+      HipstaScale.apps << Application.new(name, &block)
+    end
+    
+    def interval(interval=nil)
+      HipstaScale.interval = interval unless interval.nil?
+      HipstaScale.interval
+    end
+    
+    def heroku_key(key=nil)
+      HipstaScale.heroku_key = key unless key.nil?
+      HipstaScale.heroku_key
+    end
+    
+    def heroku_ps(name=nil)
+      HipstaScale.heroku_ps = name unless name.nil?
+      HipstaScale.heroku_ps
+    end
+    
+    def load_limit(load=nil)
+      HipstaScale.load_limit = load unless load.nil?
+      HipstaScale.load_limit
+    end
+    
+    def minimum_processes(minimum=nil)
+      HipstaScale.minimum_processes = minimum unless minimum.nil?
+      HipstaScale.minimum_processes
+    end
+    alias_method :minimum_processes, :minimum_process
+    
+    def new_relic_key(key=nil)
+      HipstaScale.new_relic_key = key unless key.nil?
+      HipstaScale.new_relic_key
+    end
+  end
+end

data/lib/hipsta_scale/heroku.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'ostruct'
+require 'rest_client'
+
+module HipstaScale
+  class Heroku    
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def expire!
+      @_cache = nil
+    end
+    
+    def fetch
+      return @_cache unless @_cache.nil?
+      json = RestClient.get(url, accept: 'json')
+      response = JSON.parse(json)
+      @_cache = response.map {|ps| OpenStruct.new(ps) }
+    end
+    
+    def processes
+      fetch.select {|ps| ps.process.match(app.heroku_ps) }
+    end
+    
+    def processes_other
+      fetch - processes
+    end
+    
+    def scale_processes(count)
+      RestClient.post("#{url}/scale?type=#{app.heroku_ps}&qty=#{count}", accept: 'json')
+    end
+  
+  private
+  
+    def url
+      "https://:#{app.heroku_key}@api.heroku.com/apps/#{app.name}/ps"
+    end
+  end
+end

data/lib/hipsta_scale/new_relic.rb

@@ -0,0 +1,45 @@
+require 'json'
+require 'ostruct'
+require 'rest_client'
+
+module HipstaScale
+  class NewRelic
+    BASE_URL = 'https://api.newrelic.com/api/v1'
+    
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def busy_percent
+      fetch.busy_percent
+    end
+    
+    def expire!
+      @_cache = nil
+    end
+    
+    def fetch
+      return @_cache unless @_cache.nil?
+      json = RestClient.get(url, 'x-api-key' => app.new_relic_key)
+      response = JSON.parse(json)
+      @_cache = OpenStruct.new(response.first)
+    end
+    
+    private
+    
+    def params
+      ''.tap do |params|
+        params << 'begin='      << (Time.now - (app.interval * 60)).strftime('%Y-%m-%dT%H:%M:%S%z')
+        params << '&end='       << Time.now.strftime('%Y-%m-%dT%H:%M:%S%z')
+        params << '&field='     << 'busy_percent'
+        params << '&metrics[]=' << 'Instance/Busy'
+      end
+    end
+    
+    def url
+      "#{BASE_URL}/applications/#{app.new_relic_id}/data.json?#{params}"
+    end
+  end
+end

data/lib/hipsta_scale/process.rb

@@ -0,0 +1,38 @@
+require 'eventmachine'
+
+module HipstaScale
+  class Process
+    
+    def self.run!
+      EventMachine.run do
+        HipstaScale.apps.each do |app|
+          Process.new(app)
+          # Simple way to make sure all of our external calls don't happen all
+          # at once.
+          sleep(10)
+        end
+      end
+    end
+    
+    def initialize(app)
+      logger.info "Check usage for #{app.name} every #{app.interval * 60} seconds"
+      EventMachine.add_periodic_timer(app.interval * 60) do
+        app.tick do
+          logger.info "[#{app.name.upcase}] Instance usage: %.2f%%" % (app.current_load * 100.0)        
+          logger.info "[#{app.name.upcase}] Amount of processes needed to reach the %.2f%% of target load: #{app.processes_needed}" % (app.load_limit * 100)
+          
+          if app.processes_needed != app.processes_running
+            logger.info "[#{app.name.upcase}] Scaling processes from #{app.processes_running} to #{app.processes_needed}"
+            app.scale!
+          end
+        end
+      end
+    end
+    
+  private
+  
+    def logger
+      HipstaScale.logger
+    end
+  end
+end

data/lib/hipsta_scale.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+module HipstaScale
+  autoload :Application, 'hipsta_scale/application'
+  autoload :Base,        'hipsta_scale/base'
+  autoload :Heroku,      'hipsta_scale/heroku'
+  autoload :NewRelic,    'hipsta_scale/new_relic'
+  autoload :Process,     'hipsta_scale/process'
+
+  # We store the global configuration information in the HipstaScale
+  # module itself for easy access across the process.
+  class << self
+    attr_accessor :heroku_key, :heroku_ps, :interval, :new_relic_key
+    attr_writer :apps, :load_limit, :logger, :minimum_processes
+  end
+  
+  def self.apps
+    @apps ||= []
+  end
+  
+  def self.load_limit
+    @load_limit || 0.8
+  end
+  
+  def self.logger
+    @logger || Logger.new(STDOUT)
+  end
+  
+  def self.minimum_processes
+    @minimum_processes || 1
+  end
+  
+  def self.run!
+    puts apps.inspect
+  end
+  
+  at_exit { Process.run! }
+end
+
+# Add out Base class (which is the DSL) to the main object space.
+extend HipstaScale::Base

data/lib/hipstascale.rb

@@ -0,0 +1 @@
+require 'hipsta_scale'

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: hipstascale
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jeremy Boles
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-30 00:00:00.000000000 Z
+dependencies: []
+description: HipstaScale helps create long-running processes that use NewRelic RPM
+  information to scale your Heroku instances before you need it.
+email: jeremy@jeremyboles.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hipsta_scale/application.rb
+- lib/hipsta_scale/base.rb
+- lib/hipsta_scale/heroku.rb
+- lib/hipsta_scale/new_relic.rb
+- lib/hipsta_scale/process.rb
+- lib/hipsta_scale.rb
+- lib/hipstascale.rb
+homepage: https://github.com/jeremyboles/hipstascale
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: HipstaScale
+test_files: []