autoscaler 0.8.0 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1870d13f3e44b1d9b2267f41fb8f5d94c94c6ec
+  data.tar.gz: 0a7662b031e66c6d9967567cb7612791fe6914ff
+SHA512:
+  metadata.gz: 10566a1b1762379530e22dbfe1174212c7c23dc4078787fffdb9956d80d3dc33a4d1aba2c9298b1408579fbda1e336e05a9b1eb63124d6bfb48fd8b90de0cc94
+  data.tar.gz: 37fd250217015d0aabf1e99cc7773aacdbf51e6ed57bfbda0a18fe998369459b69fcbcf1126fa467ba1906539e4d20b12134ec944c17c2071849e61c5243f0ff

data/CHANGELOG.md

@@ -1,9 +1,21 @@
 # Changelog
 
+## 0.9.0
+
+- CounterCacheRedis.new now takes a third parameter `worker_type`, a string used in the
+  Redis cache key. Allows for caching counts for various types of workers, not just `worker`
+- Support for Sidekiq 3.0
+- Strategy wrapper to ignore scheduled and retrying queues. Usage:
+    ``new_strategy = IgnoreScheduledAndRetrying.new(my_old_strategy)``
+- LinearScalingStrategy now accepts a minimum amount of work (as a percentage of worker capacity)
+  required to begin scaling up. E.g LinearScalingStrategy.new(10, 4, 0.5) will scale to one worker
+  after 4*0.5 = 2 jobs are enqueued, and a maximum of 10 workers at 10*4 jobs. Old behavior is preserved
+  with a default value of 0.
+
 ## 0.8.0
 
-- Extracted caching of Heroku worker counts and added experimental Redis cache
-    scaler.counter_cache = Autoscaler::CounterCacheRedis(Sidekiq.method(:redis))
+- Extracted caching of Heroku worker counts and added experimental Redis cache:
+    ``scaler.counter_cache = Autoscaler::CounterCacheRedis.new(Sidekiq.method(:redis))``
 - Now rescues Heroku::Api::Errors in addition to Excon::Errors
 
 ## 0.7.0

data/Guardfile

@@ -2,14 +2,13 @@ guard 'process', :name => 'redis', :command => 'redis-server spec/redis_test.con
   watch('spec/redis_test.conf')
 end
 
-tag = "--tag #{ENV['TAG']}" if ENV['TAG']
-example = "-e '#{ENV['EXAMPLE']}'" if ENV['EXAMPLE']
-guard 'rspec',
-    :version => 2,
-    :cli => "--color --format d #{tag} #{example}",
-    :bundler => false,
-    :spec_paths => ['spec'] do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+).rb$}) { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
+tag     = "--tag #{ENV['TAG']}"           if ENV['TAG']
+example = "--example '#{ENV['EXAMPLE']}'" if ENV['EXAMPLE']
+%w(sidekiq-2 sidekiq-3).each do |appraisal|
+  guard :rspec, :cmd => "appraisal #{appraisal} rspec --color --format d #{tag} #{example}" do
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^lib/(.+).rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+    watch('spec/spec_helper.rb')  { "spec" }
+  end
 end
+

data/lib/autoscaler/counter_cache_redis.rb

@@ -7,14 +7,16 @@ module Autoscaler
     #   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)
+    # @param [String] worker_type the name of the worker type, for cache keys
+    def initialize(redis, timeout = 5 * 60, worker_type = 'worker')
       @redis = redis
       @timeout = timeout
+      @worker_type = worker_type
     end
 
     # @param [Numeric] value new counter value
     def counter=(value)
-      redis {|c| c.setex('autoscaler:workers', @timeout, value)}
+      redis {|c| c.setex(key, @timeout, value)}
     end
 
     # Raised when no block is provided to #counter
@@ -22,7 +24,7 @@ module Autoscaler
 
     # 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')}
+      value = redis {|c| c.get(key)}
       return value.to_i if value
       return yield if block_given?
       raise Expired
@@ -31,6 +33,10 @@ module Autoscaler
     private
     attr_reader :timeout
 
+    def key
+      ['autoscaler', 'workers', @worker_type] * ':'
+    end
+
     def redis(&block)
       if @redis.respond_to?(:call)
         @redis.call(&block)

data/lib/autoscaler/ignore_scheduled_and_retrying.rb

@@ -0,0 +1,13 @@
+module Autoscaler
+  class IgnoreScheduledAndRetrying
+    def initialize(strategy)
+      @strategy = strategy
+    end
+
+    def call(system, event_idle_time)
+      system.define_singleton_method(:scheduled) { 0 }
+      system.define_singleton_method(:retrying)  { 0 }
+      @strategy.call(system, event_idle_time)
+    end
+  end
+end

data/lib/autoscaler/linear_scaling_strategy.rb

@@ -2,24 +2,29 @@ module Autoscaler
   # Strategies determine the target number of workers
   # This strategy sets the number of workers to be proportional to the number of enqueued jobs.
   class LinearScalingStrategy
-    #@param [integer] workers maximum number of workers to spin up.
+    #@param [integer] max_workers     maximum number of workers to spin up.
     #@param [integer] worker_capacity the amount of jobs one worker can handle
-    def initialize(workers = 1, worker_capacity = 25)
-      @workers         = workers
-      @worker_capacity = worker_capacity
+    #@param [float]   min_factor      minimum work required to scale, as percentage of worker_capacity
+    def initialize(max_workers = 1, worker_capacity = 25, min_factor = 0)
+      @max_workers             = max_workers # max # of workers we can scale to
+      @total_capacity          = (@max_workers * worker_capacity).to_f # total capacity of max workers
+      min_capacity             = [0, min_factor].max.to_f * worker_capacity # min capacity required to scale first worker
+      @min_capacity_percentage = min_capacity / @total_capacity # min percentage of total capacity
     end
 
     # @param [QueueSystem] system interface to the queuing system
     # @param [Numeric] event_idle_time number of seconds since a job related event
     # @return [Integer] target number of workers
     def call(system, event_idle_time)
-      total_capacity   = (@workers * @worker_capacity).to_f
-      percent_capacity = total_work(system) / total_capacity
+      requested_capacity_percentage = total_work(system) / @total_capacity
 
-      ideal_scale = (percent_capacity * @workers).ceil
-      max_scale   = @workers
+      # Scale requested capacity taking into account the minimum required
+      scale_factor = (requested_capacity_percentage - @min_capacity_percentage) / (@total_capacity - @min_capacity_percentage)
+      scaled_capacity_percentage = scale_factor * @total_capacity
 
-      return [ideal_scale, max_scale].min
+      ideal_workers = ([0, scaled_capacity_percentage].max * @max_workers).ceil
+
+      return [ideal_workers, @max_workers].min
     end
 
     private

data/lib/autoscaler/sidekiq/activity.rb

@@ -5,8 +5,9 @@ module Autoscaler
     # Tracks activity timeouts using Sidekiq's redis connection
     class Activity
       # @param [Numeric] timeout number of seconds to wait before shutdown
-      def initialize(timeout)
+      def initialize(timeout, redis = ::Sidekiq.method(:redis))
         @timeout = timeout
+        @redis   = redis
       end
 
       # Record that a queue has activity
@@ -38,13 +39,23 @@ module Autoscaler
       end
 
       def last_activity(queues)
-        ::Sidekiq.redis {|c|
+        redis {|c|
           queues.map {|q| c.get('background_activity:'+q)}.compact.max
         }
       end
 
       def active_at(queue, time)
-        ::Sidekiq.redis {|c| c.set('background_activity:'+queue, time)}
+        redis {|c| c.set('background_activity:'+queue, time)}
+      end
+
+      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/sidekiq/client.rb

@@ -13,7 +13,7 @@ module Autoscaler
       end
 
       # Sidekiq middleware api method
-      def call(worker_class, item, queue)
+      def call(worker_class, item, queue, _ = nil)
         result = yield
 
         scaler = @scalers[queue]

data/lib/autoscaler/sidekiq/entire_queue_system.rb

@@ -17,12 +17,12 @@ module Autoscaler
 
       # @return [Integer] amount of work scheduled for some time in the future
       def scheduled
-        count_sorted_set("schedule")
+        ::Sidekiq::ScheduledSet.new.size
       end
 
       # @return [Integer] amount of work still being retried
       def retrying
-        count_sorted_set("retry")
+        ::Sidekiq::RetrySet.new.size
       end
 
       # @return [Array[String]]
@@ -35,10 +35,6 @@ module Autoscaler
       def sidekiq_queues
         ::Sidekiq::Stats.new.queues
       end
-
-      def count_sorted_set(sorted_set)
-        ::Sidekiq::SortedSet.new(sorted_set).count
-      end
     end
   end
 end

data/lib/autoscaler/sidekiq/monitor_middleware_adapter.rb

@@ -21,7 +21,7 @@ module Autoscaler
       end
 
       # Sidekiq middleware api entry point
-      def call(worker, msg, queue)
+      def call(worker, msg, queue, _ = nil)
         monitor.async.starting_job
         yield
       ensure

data/lib/autoscaler/sidekiq/sleep_wait_server.rb

@@ -10,42 +10,41 @@ module Autoscaler
       # @param [Numeric] timeout number of seconds to wait before shutdown
       # @param [Array[String]] specified_queues list of queues to monitor to determine if there is work left.  Defaults to all sidekiq queues.
       def initialize(scaler, timeout, specified_queues = nil)
-        @scaler = scaler
-        @activity = Activity.new(timeout)
-        @system = QueueSystem.new(specified_queues)
+        @scaler  = scaler
+        @timeout = timeout
+        @system  = QueueSystem.new(specified_queues)
       end
 
       # Sidekiq middleware api entry point
-      def call(worker, msg, queue)
-        working!(queue)
+      def call(worker, msg, queue, redis = ::Sidekiq.method(:redis))
+        working!(queue, redis)
         yield
       ensure
-        working!(queue)
-        wait_for_task_or_scale
+        working!(queue, redis)
+        wait_for_task_or_scale(redis)
       end
 
       private
-      def wait_for_task_or_scale
+      def wait_for_task_or_scale(redis)
         loop do
           return if pending_work?
-          return @scaler.workers = 0 if idle?
+          return @scaler.workers = 0 if idle?(redis)
           sleep(0.5)
         end
       end
 
       attr_reader :system
-      attr_reader :activity
 
       def pending_work?
         system.queued > 0 || system.scheduled > 0 || system.retrying > 0
       end
 
-      def working!(queue)
-        activity.working!(queue)
+      def working!(queue, redis)
+        Activity.new(@timeout, redis).working!(queue)
       end
 
-      def idle?
-        activity.idle?(system.queue_names)
+      def idle?(redis)
+        Activity.new(@timeout, redis).idle?(system.queue_names)
       end
     end
   end

data/lib/autoscaler/sidekiq/specified_queue_system.rb

@@ -24,12 +24,12 @@ module Autoscaler
 
       # @return [Integer] amount of work scheduled for some time in the future
       def scheduled
-        count_sorted_set("schedule")
+        count_set(::Sidekiq::ScheduledSet.new)
       end
 
       # @return [Integer] amount of work still being retried
       def retrying
-        count_sorted_set("retry")
+        count_set(::Sidekiq::RetrySet.new)
       end
 
       # @return [Array[String]]
@@ -40,9 +40,8 @@ module Autoscaler
         ::Sidekiq::Stats.new.queues
       end
 
-      def count_sorted_set(sorted_set)
-        ss = ::Sidekiq::SortedSet.new(sorted_set)
-        ss.count { |job| queue_names.include?(job.queue) }
+      def count_set(set)
+        set.count { |job| queue_names.include?(job.queue) }
       end
     end
   end

data/lib/autoscaler/version.rb

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

data/spec/autoscaler/counter_cache_redis_spec.rb

@@ -18,6 +18,15 @@ describe Autoscaler::CounterCacheRedis do
     subject.counter.should == 2
   end
 
+  it 'does not conflict with multiple worker types' do
+    other_worker_cache = cut.new(@redis, 300, 'other_worker')
+    subject.counter = 1
+    other_worker_cache.counter = 2
+
+    subject.counter.should == 1
+    other_worker_cache.counter = 2
+  end
+
   it 'times out' do
     cache = cut.new(Sidekiq.method(:redis), 1) # timeout 0 invalid
     cache.counter = 3

data/spec/autoscaler/ignore_scheduled_and_retrying_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'test_system'
+require 'autoscaler/ignore_scheduled_and_retrying'
+
+describe Autoscaler::IgnoreScheduledAndRetrying do
+  let(:cut) {Autoscaler::IgnoreScheduledAndRetrying}
+
+  it "passes through enqueued" do
+    system = Struct.new(:enqueued).new(3)
+    strategy = proc {|system, time| system.enqueued}
+    cut.new(strategy).call(system, 0).should == 3
+  end
+
+  it "passes through workers" do
+    system = Struct.new(:workers).new(3)
+    strategy = proc {|system, time| system.workers}
+    cut.new(strategy).call(system, 0).should == 3
+  end
+
+  it "ignores scheduled" do
+    system = Struct.new(:scheduled).new(3)
+    strategy = proc {|system, time| system.scheduled}
+    cut.new(strategy).call(system, 0).should == 0
+  end
+
+  it "ignores retrying" do
+    system = Struct.new(:retrying).new(3)
+    strategy = proc {|system, time| system.retrying}
+    cut.new(strategy).call(system, 0).should == 0
+  end
+end
+
+

data/spec/autoscaler/linear_scaling_strategy_spec.rb

@@ -34,4 +34,46 @@ describe Autoscaler::LinearScalingStrategy do
     strategy = cut.new(5, 2)
     strategy.call(system, 1).should == 3
   end
+
+  it "doesn't scale unless minimum is met" do
+    system = TestSystem.new(2)
+    strategy = cut.new(10, 4, 0.5)
+    strategy.call(system, 1).should == 0
+  end
+
+  it "scales proprotionally with a minimum" do
+    system = TestSystem.new(3)
+    strategy = cut.new(10, 4, 0.5)
+    strategy.call(system, 1).should == 1
+  end
+
+  it "scales maximally with a minimum" do
+    system = TestSystem.new(25)
+    strategy = cut.new(5, 4, 0.5)
+    strategy.call(system, 1).should == 5
+  end
+
+  it "scales proportionally with a minimum > 1" do
+    system = TestSystem.new(12)
+    strategy = cut.new(5, 4, 2)
+    strategy.call(system, 1).should == 2
+  end
+
+  it "scales maximally with a minimum factor > 1" do
+    system = TestSystem.new(30)
+    strategy = cut.new(5, 4, 2)
+    strategy.call(system, 1).should == 5
+  end
+
+  xit "doesn't scale down engaged workers" do
+    system = TestSystem.new(0, 2)
+    strategy = cut.new(5, 4)
+    strategy.call(system, 1).should == 2
+  end
+
+  xit "doesn't scale above max workers even if engaged workers is greater" do
+    system = TestSystem.new(40, 6)
+    strategy = cut.new(5, 4)
+    strategy.call(system, 1).should == 5
+  end
 end

data/spec/autoscaler/sidekiq/activity_spec.rb

@@ -18,4 +18,17 @@ describe Autoscaler::Sidekiq::Activity do
     end
     it {activity.should be_idle(['queue'])}
   end
+
+  it 'passed a connection pool' do
+    activity = cut.new(5, @redis)
+    activity.working!('queue')
+    activity.should_not be_idle(['queue'])
+  end
+
+  it 'passed a plain connection' do
+    connection = Redis.connect(:url => 'http://localhost:9736', :namespace => 'autoscaler')
+    activity = cut.new(5, connection)
+    activity.working!('queue')
+    activity.should_not be_idle(['queue'])
+  end
 end

data/spec/autoscaler/sidekiq/client_spec.rb

@@ -13,6 +13,11 @@ describe Autoscaler::Sidekiq::Client do
       scaler.workers.should == 1
     end
 
+    it 'scales with a redis pool' do
+      client.call(Class, {}, 'queue', ::Sidekiq.method(:redis)) {}
+      scaler.workers.should == 1
+    end
+
     it('yields') {client.call(Class, {}, 'queue') {:foo}.should == :foo}
   end
 

data/spec/autoscaler/sidekiq/monitor_middleware_adapter_spec.rb

@@ -12,4 +12,5 @@ describe Autoscaler::Sidekiq::MonitorMiddlewareAdapter do
   let(:server) {cut.new(scaler, 0, ['queue'])}
 
   it('yields') {server.call(Object.new, {}, 'queue') {:foo}.should == :foo}
+  it('yields with a redis pool') {server.call(Object.new, {}, 'queue', Sidekiq.method(:redis)) {:foo}.should == :foo}
 end

data/spec/autoscaler/sidekiq/sleep_wait_server_spec.rb

@@ -11,10 +11,7 @@ describe Autoscaler::Sidekiq::SleepWaitServer do
   let(:scaler) {TestScaler.new(1)}
   let(:server) {cut.new(scaler, 0, ['queue'])}
 
-  def when_run
-    server.call(Object.new, {}, 'queue') {}
-  end
-
+  shared_examples "a sleepwait server" do
   it "scales with no work" do
     server.stub(:pending_work?).and_return(false)
     when_run
@@ -26,6 +23,23 @@ describe Autoscaler::Sidekiq::SleepWaitServer do
     when_run
     scaler.workers.should == 1
   end
+  end
+
+  describe "a middleware with no redis specified" do
+  it_behaves_like "a sleepwait server" do
+  def when_run
+    server.call(Object.new, {}, 'queue') {}
+  end
+  end
+  end
+
+  describe "a middleware with redis specified" do
+  it_behaves_like "a sleepwait server" do
+  def when_run
+    server.call(Object.new, {}, 'queue', Sidekiq.method(:redis)) {}
+  end
+  end
+  end
 
   it('yields') {server.call(Object.new, {}, 'queue') {:foo}.should == :foo}
 end

data/spec/test_system.rb

@@ -1,9 +1,10 @@
 class TestSystem
-  def initialize(pending)
+  def initialize(pending, current = 0)
     @pending = pending
+    @current = current
   end
 
-  def workers; 0; end
+  def workers; @current; end
   def queued; @pending; end
   def scheduled; 0; end
   def retrying; 0; end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: autoscaler
 version: !ruby/object:Gem::Version
-  version: 0.8.0
-  prerelease: 
+  version: 0.9.0
 platform: ruby
 authors:
 - Justin Love
@@ -10,102 +9,96 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-07 00:00:00.000000000 Z
+date: 2014-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: heroku-api
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-process
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Currently provides a Sidekiq middleware that does 0/1 scaling of Heroku
@@ -117,13 +110,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- Guardfile
 - README.md
+- examples/complex.rb
+- examples/simple.rb
+- lib/autoscaler.rb
 - 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/ignore_scheduled_and_retrying.rb
 - lib/autoscaler/linear_scaling_strategy.rb
+- lib/autoscaler/sidekiq.rb
 - lib/autoscaler/sidekiq/activity.rb
 - lib/autoscaler/sidekiq/celluloid_monitor.rb
 - lib/autoscaler/sidekiq/client.rb
@@ -132,18 +131,14 @@ files:
 - lib/autoscaler/sidekiq/queue_system.rb
 - lib/autoscaler/sidekiq/sleep_wait_server.rb
 - lib/autoscaler/sidekiq/specified_queue_system.rb
-- lib/autoscaler/sidekiq.rb
 - lib/autoscaler/stub_scaler.rb
 - lib/autoscaler/version.rb
-- lib/autoscaler.rb
-- examples/complex.rb
-- 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/ignore_scheduled_and_retrying_spec.rb
 - spec/autoscaler/linear_scaling_strategy_spec.rb
 - spec/autoscaler/sidekiq/activity_spec.rb
 - spec/autoscaler/sidekiq/celluloid_monitor_spec.rb
@@ -156,27 +151,26 @@ files:
 - spec/test_system.rb
 homepage: ''
 licenses: []
+metadata: {}
 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: autoscaler
-rubygems_version: 1.8.25
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Start/stop Sidekiq workers on Heroku
 test_files:
 - Guardfile
@@ -185,6 +179,7 @@ test_files:
 - spec/autoscaler/counter_cache_redis_spec.rb
 - spec/autoscaler/delayed_shutdown_spec.rb
 - spec/autoscaler/heroku_scaler_spec.rb
+- spec/autoscaler/ignore_scheduled_and_retrying_spec.rb
 - spec/autoscaler/linear_scaling_strategy_spec.rb
 - spec/autoscaler/sidekiq/activity_spec.rb
 - spec/autoscaler/sidekiq/celluloid_monitor_spec.rb