heroku_auto_scale 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49c7a5cc62bb1678668a81d5eaf42a9926c68a60
+  data.tar.gz: 0a785b077800bf7df5a0e84a07ffe604bf286c1a
+SHA512:
+  metadata.gz: cf0fac72297a756ef03071588309eaab6ef55240868894f3f43e1c3673bcd166bb752f1b78294dc4da16dfdf9de477fae6699a8ae53cc26d305e9600b6c7dc9e
+  data.tar.gz: d3e741458014a95a4d10ecd0ba11a82149e798be2a36e00a630a937a69b29634feaa5499cc33e308ceb275bb7a2ed91695479b5dcafca755f2d5086b64001b08

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format documentation
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in heroku_auto_scale.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 luki3k5
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# HerokuAutoScale
+
+Idea of this gem is to allow for simple and queue system agnostic
+scalability of background jobs on heroku.
+
+Imagine having multimple queues of some kind, each time there are no
+jobs these queues are just hanging there - wasting their time staying online. 
+On the other hand when there is a spike in number of scheduled jobs it would be
+good to increase the number of dynos to process them faster.
+
+This gem provides simple DSL for doing just that.
+It allows to set a meaningful constrains for your dynos such as
+minimum/maximum number of dynos and scaling step.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'heroku_auto_scale'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install heroku_auto_scale
+
+In case of rails applications you may want to create new initializer
+with the following content:
+
+```ruby
+
+include HerokuAutoScale
+
+HerokuAutoScale.configure do |c|
+  c.redis_url          = ENV['REDISCLOUD_URL']
+  c.heroku_oauth_token = ENV['HEROKU_TOKEN']
+  c.heroku_app_name    = ENV['APP_NAME']
+end
+
+
+```
+
+Make sure that you have corresponding environment variables setup.
+
+## Usage
+
+Below is simple example how to use this gem:
+
+```ruby
+
+heroku_observe do
+  queue_name   "queue:followers_jobs"
+  process_name "sidekiq_followers"
+
+  max_dynos 2
+  min_dynos 1
+  scaling_step 2000
+end
+
+```
+
+The meaning of options is:
+- queue_name - the name of the queue in redis that you wish to observe
+- process_name - name of the heroku process to scale
+- max_dynos - maximum number of dynos you want to scale up to 
+- min_dynos - minimum number of dynos you want to scale down to
+- scaling_step - number of jobs it take to scale your dynos
+
+For adding timely checks I recommend using great [clockwork](https://github.com/adamwiggins/clockwork)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/heroku_auto_scale/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/heroku_auto_scale.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'heroku_auto_scale/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "heroku_auto_scale"
+  spec.version       = HerokuAutoScale::VERSION
+  spec.authors       = ["luki3k5"]
+  spec.email         = ["luki3k5@gmail.com"]
+  spec.summary       = %q{Simple DSL for creating scaling rules for worker dynos on Heroku}
+  spec.description   = %q{Simple DSL for creating scaling rules for worker dynos on Heroku}
+  spec.homepage      = ""
+  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 'platform-api'
+  spec.add_dependency 'redis'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "rspec-collection_matchers"
+  spec.add_development_dependency "webmock"
+
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "pry"
+end

data/lib/heroku_auto_scale.rb

@@ -0,0 +1,52 @@
+require "heroku_auto_scale/version"
+require "heroku_auto_scale/manager"
+require "heroku_auto_scale/configuration"
+
+module HerokuAutoScale
+  extend Configuration
+
+  class << self
+    def included(includer)
+      includer.send("include", Methods)
+      includer.extend(Methods)
+    end
+
+    def manager
+      @manager ||= Manager.new
+    end
+  end
+
+  module Methods
+
+    def heroku_observe
+      yield
+      manage_queue
+    end
+
+    def process_name(process_name)
+      HerokuAutoScale.manager.set_process_name(process_name)
+    end
+
+    def queue_name(queue_name)
+      HerokuAutoScale.manager.set_queue_name(queue_name)
+    end
+
+    def scaling_step(step)
+      HerokuAutoScale.manager.set_scaling_step(step)
+    end
+
+    def max_dynos(number_of_dynos)
+      HerokuAutoScale.manager.set_max_dynos(number_of_dynos)
+    end
+
+    def min_dynos(number_of_dynos)
+      HerokuAutoScale.manager.set_min_dynos(number_of_dynos)
+    end
+
+    def manage_queue
+      HerokuAutoScale.manager.manage_queue
+    end
+  end
+
+  extend Methods
+end

data/lib/heroku_auto_scale/configuration.rb

@@ -0,0 +1,21 @@
+module HerokuAutoScale
+  module Configuration
+    CONFIGURATION_OPTIONS = [
+      :redis_url,
+      :heroku_oauth_token,
+      :heroku_app_name
+    ].freeze
+
+    attr_accessor *CONFIGURATION_OPTIONS
+
+    def configure
+      yield self
+    end
+
+    def options
+      CONFIGURATION_OPTIONS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+  end
+end

data/lib/heroku_auto_scale/heroku_operations.rb

@@ -0,0 +1,32 @@
+require 'platform-api'
+
+module HerokuAutoScale
+  class HerokuOperations
+    attr_reader :heroku_connection, :app_name
+
+    def initialize(api_key, app_name)
+      @heroku_connection = PlatformAPI.connect_oauth(api_key)
+      @app_name          = app_name
+    end
+
+    def execute_dyno_scale(process_name, new_number_of_dynos)
+      if should_scale?(process_name, new_number_of_dynos)
+        scale_dynos(process_name, new_number_of_dynos)
+      end
+    end
+
+    private
+      def scale_dynos(process_name, new_number_of_dynos)
+        heroku_connection.formation.update(
+          app_name,
+          process_name,
+          {"quantity" => new_number_of_dynos}
+        )
+      end
+
+      def should_scale?(process_name, new_number_of_dynos)
+        response = heroku_connection.formation.info(app_name, process_name)
+        response["quantity"] != new_number_of_dynos
+      end
+  end
+end

data/lib/heroku_auto_scale/manager.rb

@@ -0,0 +1,81 @@
+require 'heroku_auto_scale/redis_operations'
+require 'heroku_auto_scale'
+require 'heroku_auto_scale/configuration'
+require 'heroku_auto_scale/heroku_operations'
+
+module HerokuAutoScale
+  class Manager
+    MNGR_ATTRIBUTES = [
+      :process_name,
+      :queue_name,
+      :redis_operations,
+      :heroku_operations,
+      :min_dynos,
+      :max_dynos,
+      :scaling_step
+    ].freeze
+
+    attr_accessor *HerokuAutoScale::Configuration::CONFIGURATION_OPTIONS
+    attr_accessor *MNGR_ATTRIBUTES
+
+    def initialize(options={})
+      options = HerokuAutoScale.options.merge(options)
+      Configuration::CONFIGURATION_OPTIONS.each do |key|
+        send("#{key}=", options[key])
+      end
+
+      init_redis_operations
+      init_heroku_operations
+    end
+
+    def get_number_of_jobs_inside_queue
+      redis_operations.check_queue_for_jobs(@queue_name)
+    end
+
+    def set_process_name(process_name)
+      @process_name = process_name
+    end
+
+    def set_queue_name(queue_name)
+      @queue_name = queue_name
+    end
+
+    def set_min_dynos(min_dynos)
+      @min_dynos = min_dynos
+    end
+
+    def set_max_dynos(max_dynos)
+      @max_dynos = max_dynos
+    end
+
+    def set_scaling_step(scaling_step)
+      @scaling_step = scaling_step
+    end
+
+    def manage_queue
+      scale_to = calculate_number_of_needed_dynos
+      heroku_operations.execute_dyno_scale(process_name, scale_to)
+    end
+
+    def calculate_number_of_needed_dynos
+      current_jobs = get_number_of_jobs_inside_queue
+      dynos = (current_jobs.to_f / scaling_step.to_f).ceil
+
+      scale_to = [dynos, max_dynos].min
+      scale_to = [scale_to, min_dynos].max
+    end
+
+    private
+      def init_redis_operations
+        @redis_operations = HerokuAutoScale::RedisOperations.new(redis_url)
+      end
+
+      def init_heroku_operations
+        @heroku_operations = HerokuAutoScale::
+          HerokuOperations.new(
+            heroku_oauth_token,
+            heroku_app_name
+        )
+      end
+  end
+end

data/lib/heroku_auto_scale/redis_operations.rb

@@ -0,0 +1,26 @@
+require 'redis'
+
+module HerokuAutoScale
+  class RedisOperations
+    attr_reader :redis_connection
+
+    def initialize(url)
+      @redis_connection = Redis.new(url: url)
+    end
+
+    def check_queue_for_jobs(queue_name)
+      check_queue(queue_name)
+      redis_connection.llen(queue_name)
+    end
+
+    private
+      def check_queue(queue_name)
+        available_keys = redis_connection.keys
+        unless available_keys.include?(queue_name)
+          raise "There is no key #{queue_name}, \n
+                 available keys are:\n
+                 #{available_keys}"
+        end
+      end
+  end
+end

data/lib/heroku_auto_scale/version.rb

@@ -0,0 +1,3 @@
+module HerokuAutoScale
+  VERSION = "0.0.1"
+end

data/spec/heroku_auto_scale/configuration_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe HerokuAutoScale::Configuration do
+  subject do
+    Object.new.extend(HerokuAutoScale::Configuration)
+  end
+
+  it 'allows to set allowed attributes' do
+    subject.configure do |c|
+      c.redis_url = 'url'
+      c.heroku_oauth_token = 'token'
+      c.heroku_app_name = 'app'
+    end
+
+    expect(subject.redis_url).to          eq('url')
+    expect(subject.heroku_oauth_token).to eq('token')
+    expect(subject.heroku_app_name).to    eq('app')
+  end
+
+  it 'retuns hash of it\'s attributes' do
+    subject.configure do |c|
+      c.redis_url = 'url'
+      c.heroku_oauth_token = 'token'
+      c.heroku_app_name = 'app'
+    end
+
+    expect(subject.options).to eq({
+      :redis_url=>"url",
+      :heroku_oauth_token=>"token",
+      :heroku_app_name=>"app"
+    })
+  end
+
+end

data/spec/heroku_auto_scale/heroku_operations_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe HerokuAutoScale::HerokuOperations do
+  subject { HerokuAutoScale::HerokuOperations.new("api_key", "app_name") }
+
+  let(:heroku_info_response) do
+    {
+      "command"    => "bundle exec fake_process_name",
+      "created_at" => "2015-04-13T11:36:03Z",
+      "id"         => "xxx-xxx-xxx-xxx",
+      "type"       => "sidekiq_followers",
+      "quantity"   => 1,
+      "size"       => "2X",
+      "updated_at" => "2015-05-10T17:26:08Z"
+    }
+  end
+
+  context 'should_scale?' do
+    it 'doesn\'t allow to scale for the same no. of dynos' do
+      allow(subject).to receive_message_chain(:heroku_connection, :formation, :info).
+        and_return(heroku_info_response)
+      expect(subject.send(:should_scale?, "process_name", 1)).to eq(false)
+    end
+
+    it 'does allow to scale for the greater no. of dynos' do
+      allow(subject).to receive_message_chain(:heroku_connection, :formation, :info).
+        and_return(heroku_info_response)
+      expect(subject.send(:should_scale?, "process_name", 2)).to eq(true)
+    end
+
+    it 'does allow to scale for the smaller no. of dynos' do
+      allow(subject).to receive_message_chain(:heroku_connection, :formation, :info).
+        and_return(heroku_info_response)
+      expect(subject.send(:should_scale?, "process_name", 0)).to eq(true)
+    end
+  end
+
+end

data/spec/heroku_auto_scale/manager_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe HerokuAutoScale::Manager do
+  let(:redis_test_url_for_test)     { "redis://localhost" }
+  let(:heroku_oauth_token_for_test) { "token" }
+  let(:heroku_app_name_for_test)    { "app" }
+  let(:config_values) do
+    [
+      redis_test_url_for_test,
+      heroku_oauth_token_for_test,
+      heroku_app_name_for_test
+    ]
+  end
+
+  before do
+    @keys = HerokuAutoScale::Configuration::CONFIGURATION_OPTIONS
+  end
+
+  context 'configuration' do
+    before(:each) do
+      HerokuAutoScale.configure do |c|
+        c.redis_url          = redis_test_url_for_test
+        c.heroku_oauth_token = heroku_oauth_token_for_test
+        c.heroku_app_name    = heroku_app_name_for_test
+      end
+    end
+
+    it 'should inherit the config' do
+      manager = HerokuAutoScale::Manager.new
+      @keys.each do |key|
+        expect(
+          config_values.include?(manager.send(key))
+        ).to eq(true)
+      end
+    end
+  end
+
+  context 'accepting attributes' do
+    let(:manager) { HerokuAutoScale::Manager.new }
+
+    it '#set_process_name' do
+      manager.set_process_name("some_process_name")
+      expect(manager.process_name).to eq("some_process_name")
+    end
+
+    it '#set_queue_name' do
+      manager.set_queue_name("some_queue_name")
+      expect(manager.queue_name).to eq("some_queue_name")
+    end
+
+    it '#set_min_dynos' do
+      manager.set_min_dynos(1)
+      expect(manager.min_dynos).to eq(1)
+    end
+
+    it '#set_max_dynos' do
+      manager.set_max_dynos(2)
+      expect(manager.max_dynos).to eq(2)
+    end
+
+    it '#set_scaling_step' do
+      manager.set_scaling_step(12000)
+      expect(manager.scaling_step).to eq(12000)
+    end
+
+  end
+
+  describe 'dynos numbers for scalability' do
+    let(:manager) { HerokuAutoScale::Manager.new }
+
+    it 'sets 0 dynos when there are no jobs and min_dynos(0)' do
+      manager.set_scaling_step(10_000)
+      manager.set_min_dynos(0)
+      manager.set_max_dynos(10)
+      allow(manager).to receive(:get_number_of_jobs_inside_queue) { 0 }
+
+      expect(manager.calculate_number_of_needed_dynos).to eq(0)
+    end
+
+    it 'sets to min dynos when there are no jobs and min_dynos(1)' do
+      manager.set_scaling_step(10_000)
+      manager.set_min_dynos(1)
+      manager.set_max_dynos(10)
+      allow(manager).to receive(:get_number_of_jobs_inside_queue) { 0 }
+
+      expect(manager.calculate_number_of_needed_dynos).to eq(1)
+    end
+
+    it 'sets 1 dynos when there are jobs till the first scaling_step' do
+      manager.set_scaling_step(10_000)
+      manager.set_min_dynos(0)
+      manager.set_max_dynos(10)
+      allow(manager).to receive(:get_number_of_jobs_inside_queue) { 8_000 }
+
+      expect(manager.calculate_number_of_needed_dynos).to eq(1)
+    end
+
+    it 'sets 2 dynos when there are jobs till the second scaling_step' do
+      manager.set_scaling_step(10_000)
+      manager.set_min_dynos(0)
+      manager.set_max_dynos(10)
+      allow(manager).to receive(:get_number_of_jobs_inside_queue) { 18_000 }
+
+      expect(manager.calculate_number_of_needed_dynos).to eq(2)
+    end
+
+    it 'sets max allowed dynos when there are jobs that exceed max_dynos x scaling_step' do
+      manager.set_scaling_step(10_000)
+      manager.set_min_dynos(0)
+      manager.set_max_dynos(4)
+      allow(manager).to receive(:get_number_of_jobs_inside_queue) { 180_000 }
+
+      expect(manager.calculate_number_of_needed_dynos).to eq(4)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rspec'
+require 'rspec/collection_matchers'
+require 'heroku_auto_scale'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: heroku_auto_scale
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- luki3k5
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: platform-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  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: webmock
+  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: awesome_print
+  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: pry
+  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: Simple DSL for creating scaling rules for worker dynos on Heroku
+email:
+- luki3k5@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- heroku_auto_scale.gemspec
+- lib/heroku_auto_scale.rb
+- lib/heroku_auto_scale/configuration.rb
+- lib/heroku_auto_scale/heroku_operations.rb
+- lib/heroku_auto_scale/manager.rb
+- lib/heroku_auto_scale/redis_operations.rb
+- lib/heroku_auto_scale/version.rb
+- spec/heroku_auto_scale/configuration_spec.rb
+- spec/heroku_auto_scale/heroku_operations_spec.rb
+- spec/heroku_auto_scale/manager_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Simple DSL for creating scaling rules for worker dynos on Heroku
+test_files:
+- spec/heroku_auto_scale/configuration_spec.rb
+- spec/heroku_auto_scale/heroku_operations_spec.rb
+- spec/heroku_auto_scale/manager_spec.rb
+- spec/spec_helper.rb