vector 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 541f21bb927907e0a40dc80e6383fafadbfed41b
+  data.tar.gz: 608fb28e14b4f8b6e35ae093ef30d02346b910ca
+SHA512:
+  metadata.gz: e54156a992bdec104878d7be100673797e153198d3f9888307df09966421ec7c63833529745a4c61cba22c905f9df8b7f8c9aa56bd1900c510b12ebe97a6b30e
+  data.tar.gz: 272cdb7eba79cdc60425fb2c14dbbb793911696b62c401e695f97beeacd2f48b198e1b25e48e082013bdd747578378b532f737d8e04f929be76892de760fddfb

data/README.md

@@ -123,6 +123,21 @@ renewals - the group will not be scaled down.
 one, or else it's possible Vector may never find eligible nodes for
 scaledown and never scaledown.)
 
+### Variable Thresholds
+
+When deciding to scale down, a static CPU utilization threshold may be
+inefficient. For example, if there are 2 nodes running, and you have a
+minimum of 2, and the average CPU is 75%, removing 1 node would
+theoretically result in the remaining 2 nodes running at > 100%. However,
+with 20 nodes running, at an average CPU of 75%, removing 1 node will
+only result in an average CPU of 79% across the remaining 19 nodes.
+
+When there are more nodes running, you can be more aggressive about
+removing nodes without overloading the remaining nodes. Variable
+thresholds allow you to express this.
+
+You can enable variable thresholds with `--fds-variable-thresholds`.
+
 ### Integration with Predictive Scaling
 
 Before scaling down, and if Predictive Scaling is in effect, Vector will

data/lib/vector/cli.rb

@@ -32,14 +32,14 @@ module Vector
       if @config[:predictive_scaling][:enabled]
         psconf = @config[:predictive_scaling]
         ps = Vector::Function::PredictiveScaling.new(
-          { :cloudwatch => cloudwatch }.merge(psconf))
+          { :cloudwatch => cloudwatch, :dry_run => @config[:dry_run] }.merge(psconf))
       end
 
       fds = nil
       if @config[:flexible_down_scaling][:enabled]
         fdsconf = @config[:flexible_down_scaling]
         fds = Vector::Function::FlexibleDownScaling.new(
-          { :cloudwatch => cloudwatch }.merge(fdsconf))
+          { :cloudwatch => cloudwatch, :dry_run => @config[:dry_run] }.merge(fdsconf))
       end
 
       groups.each do |group|
@@ -71,6 +71,7 @@ module Vector
     def load_config
       opts = {
         :quiet => false,
+        :dry_run => false,
         :region => 'us-east-1',
         :groups => [],
         :fleet => nil,
@@ -85,56 +86,72 @@ module Vector
           :enabled => false,
           :up_down_cooldown => nil,
           :down_down_cooldown => nil,
-          :max_sunk_cost => nil
+          :max_sunk_cost => nil,
+          :variable_thresholds => false,
+          :n_low => nil,
+          :n_high => nil,
+          :m => nil,
+          :g_high => 1.0,
+          :g_low => 1.0
         }
       }
 
       optparser = OptionParser.new do |o|
         o.banner = "Usage: vector [options]"
         o.separator "DURATION can look like 60s, 1m, 5h, 7d, 1w"
+        o.set_summary_width 5
+        o.set_summary_indent '  '
 
-        o.on("--timezone TIMEZONE", "Timezone to use for date calculations (like America/Denver) (default: system timezone)") do |v|
+        def wrap(str)
+          str.scan(/\S.{0,#{60}}\S(?=\s|$)|\S+/).join "\n        "
+        end
+
+        o.on("--timezone TIMEZONE", wrap("Timezone to use for date calculations (like America/Denver) (default: system timezone)")) do |v|
           Time.zone = v
         end
 
-        o.on("--region REGION", "AWS region to operate in (default: us-east-1)") do |v|
+        o.on("--region REGION", wrap("AWS region to operate in (default: us-east-1)")) do |v|
           opts[:region] = v
         end
 
-        o.on("--groups group1,group2", Array, "A list of Auto Scaling Groups to evaluate") do |v|
+        o.on("--groups group1,group2", Array, wrap("A list of Auto Scaling Groups to evaluate")) do |v|
           opts[:groups] = v
         end
 
-        o.on("--fleet fleet", "An AWS ASG Fleet (instead of specifying --groups)") do |v|
+        o.on("--fleet fleet", wrap("An AWS ASG Fleet (instead of specifying --groups)")) do |v|
           opts[:fleet] = v
         end
 
-        o.on("-q", "--[no-]quiet", "Run quietly") do |v|
+        o.on("--[no-]dry-run", wrap("Don't actually trigger any policies")) do |v|
+          opts[:dry_run] = v
+        end
+
+        o.on("-q", "--[no-]quiet", wrap("Run quietly")) do |v|
           opts[:quiet] = v
         end
 
         o.separator ""
         o.separator "Predictive Scaling Options"
 
-        o.on("--[no-]ps", "Enable Predictive Scaling") do |v|
+        o.on("--[no-]ps", wrap("Enable Predictive Scaling")) do |v|
           opts[:predictive_scaling][:enabled] = v
         end
 
-        o.on("--ps-lookback-windows DURATION,DURATION", Array, "List of lookback windows") do |v|
+        o.on("--ps-lookback-windows DURATION,DURATION", Array, wrap("List of lookback windows")) do |v|
           opts[:predictive_scaling][:lookback_windows] =
             v.map {|w| Vector.time_string_to_seconds(w) }
         end
 
-        o.on("--ps-lookahead-window DURATION", String, "Lookahead window") do |v|
+        o.on("--ps-lookahead-window DURATION", String, wrap("Lookahead window")) do |v|
           opts[:predictive_scaling][:lookahead_window] =
             Vector.time_string_to_seconds(v)
         end
 
-        o.on("--ps-valid-threshold FLOAT", Float, "A number from 0.0 - 1.0 specifying how closely previous load must match current load for Predictive Scaling to take effect") do |v|
+        o.on("--ps-valid-threshold FLOAT", Float, wrap("A number from 0.0 - 1.0 specifying how closely previous load must match current load for Predictive Scaling to take effect")) do |v|
           opts[:predictive_scaling][:valid_threshold] = v
         end
 
-        o.on("--ps-valid-period DURATION", String, "The period to use when doing the threshold check") do |v|
+        o.on("--ps-valid-period DURATION", String, wrap("The period to use when doing the threshold check")) do |v|
           opts[:predictive_scaling][:valid_period] = 
             Vector.time_string_to_seconds v
         end
@@ -142,21 +159,21 @@ module Vector
         o.separator ""
         o.separator "Flexible Down Scaling Options"
 
-        o.on("--[no-]fds", "Enable Flexible Down Scaling") do |v|
+        o.on("--[no-]fds", wrap("Enable Flexible Down Scaling")) do |v|
           opts[:flexible_down_scaling][:enabled] = v
         end
 
-        o.on("--fds-up-to-down DURATION", String, "The cooldown period between up and down scale events") do |v|
+        o.on("--fds-up-to-down DURATION", String, wrap("The cooldown period between up and down scale events")) do |v|
           opts[:flexible_down_scaling][:up_down_cooldown] =
             Vector.time_string_to_seconds v
         end
 
-        o.on("--fds-down-to-down DURATION", String, "The cooldown period between down and down scale events") do |v|
+        o.on("--fds-down-to-down DURATION", String, wrap("The cooldown period between down and down scale events")) do |v|
           opts[:flexible_down_scaling][:down_down_cooldown] =
             Vector.time_string_to_seconds v
         end
 
-        o.on("--fds-max-sunk-cost DURATION", String, "Only let a scaledown occur if there is an instance this close to its hourly billing point") do |v|
+        o.on("--fds-max-sunk-cost DURATION", String, wrap("Only let a scaledown occur if there is an instance this close to its hourly billing point")) do |v|
           time = Vector.time_string_to_seconds v
           if time > 1.hour
             puts "--fds-max-sunk-cost duration must be < 1 hour"
@@ -166,6 +183,35 @@ module Vector
           opts[:flexible_down_scaling][:max_sunk_cost] = time
         end
 
+        o.separator ""
+        o.on("--[no-]fds-variable-thresholds", wrap("Enable Variable Thresholds")) do |v|
+          opts[:flexible_down_scaling][:variable_thresholds] = v
+        end
+
+        o.on("--fds-n-low NUM", Integer, wrap("Number of nodes corresponding to --fds-g-low. (default: 1 more than the group's minimum size)")) do |v|
+          opts[:flexible_down_scaling][:n_low] = v
+        end
+
+        o.on("--fds-n-high NUM", Integer, wrap("Number of nodes corresponding to --fds-g-high. (default: the group's maximum size)")) do |v|
+          opts[:flexible_down_scaling][:n_high] = v
+        end
+
+        o.on("--fds-m PERCENTAGE", Float, wrap("Maximum target utilization. Will default to the CPUUtilization alarm threshold.")) do |v|
+          opts[:flexible_down_scaling][:m] = v / 100
+        end
+
+        o.on("--fds-g-high PERCENTAGE", Float, wrap("Capacity headroom to apply when scaling down from --fds-n-high nodes, as a percentage. e.g. if this is 90%, then will not scale down from --fds-n-high nodes until expected utilization on the remaining nodes is at or below 90% of --fds-m. (default: 100)")) do |v|
+          opts[:flexible_down_scaling][:g_high] = v / 100
+        end
+
+        o.on("--fds-g-low PERCENTAGE", Float, wrap("Capacity headroom to apply when scaling down from --fds-n-low nodes, as a percentage. e.g. if this is 75%, then will not scale down from --fds-n-low nodes until expected utilization on the remaining nodes is at or below 75% of --fds-m. When scaling down from a number of nodes other than --fds-n-high or --fds-n-low, will use a capacity headroom linearly interpolated from --fds-g-high and --fds-g-low. (default: 100)")) do |v|
+          opts[:flexible_down_scaling][:g_low] = v / 100
+        end
+
+        o.on("--fds-print-variable-thresholds", wrap("Calculates and displays the thresholds that will be used for each asg, and does not execute any downscaling policies. (For debugging).")) do |v|
+          opts[:flexible_down_scaling][:print_variable_thresholds] = true
+        end
+
       end.parse!(@argv)
 
       if opts[:groups].empty? && opts[:fleet].nil?

data/lib/vector/functions/flexible_down_scaling.rb

@@ -7,9 +7,17 @@ module Vector
 
       def initialize(options)
         @cloudwatch = options[:cloudwatch]
+        @dry_run = options[:dry_run]
         @up_down_cooldown = options[:up_down_cooldown]
         @down_down_cooldown = options[:down_down_cooldown]
         @max_sunk_cost = options[:max_sunk_cost]
+        @variable_thresholds = options[:variable_thresholds]
+        @n_low = options[:n_low]
+        @n_high = options[:n_high]
+        @m = options[:m]
+        @g_low = options[:g_low]
+        @g_high = options[:g_high]
+        @debug_variable_thresholds = options[:print_variable_thresholds]
       end
 
       def run_for(group, ps_check_procs)
@@ -38,6 +46,7 @@ module Vector
               hlog_ctx("policy:#{policy.name}") do
                 # TODO: support adjustment types other than ChangeInCapacity here
                 if policy.adjustment_type == "ChangeInCapacity" &&
+                   ps_check_procs &&
                    ps_check_procs.any? {|ps_check_proc|
                      ps_check_proc.call(group.desired_capacity + policy.scaling_adjustment) }
                   hlog("Predictive scaleup would trigger a scaleup if group were shrunk")
@@ -54,11 +63,76 @@ module Vector
                   !alarm.enabled?
                 end
 
+                # Do this logic first in case the user is just trying to print out
+                # the thresholds.
+                if @variable_thresholds
+                  # variable_thresholds currently requires a CPUUtilization alarm to function
+                  vt_cpu_alarm = disabled_alarms.find {|alarm| alarm.metric_name == "CPUUtilization" }
+
+                  # remove this alarm from the check, since we're not checking its alarm status
+                  # below.
+                  disabled_alarms.delete(vt_cpu_alarm)
+
+                  unless vt_cpu_alarm
+                    hlog("Variable thresholds requires an alarm on CPUUtilization, skipping")
+                    next
+                  end
+
+                  @n_low ||= group.min_size + 1
+                  @n_high ||= group.max_size
+                  @m ||= vt_cpu_alarm.threshold / 100
+
+                  if @g_low == @g_high
+                    hlog("g_low == g_high (#{@g_low}), not attempting to use flexible thresholds.")
+                    next
+                  end
+
+                  if @n_low == @n_high
+                    hlog("n_low == n_high (#{@n_low}), not attempting to use flexible thresholds.")
+                    next
+                  end
+
+                  if @debug_variable_thresholds
+                    puts "  n_low: #{@n_low}"
+                    puts " n_high: #{@n_high}"
+                    puts "      m: #{@m}"
+                    puts "  g_low: #{@g_low}"
+                    puts " g_high: #{@g_high}"
+                    puts
+                    puts "  N  Threshold"
+                    ([@n_low, group.min_size].min + 1).upto([@n_high, group.max_size].max) do |i|
+                      puts " %2d  %.1f%%" % [i, (variable_threshold(i, @n_low, @n_high, @m, @g_low, @g_high) * 100)]
+                    end
+                    next
+                  end
+                end
+
                 unless disabled_alarms.all? {|alarm| alarm.state_value == "ALARM" }
                   hlog("Not all alarms are in ALARM state")
                   next
                 end
 
+                if @variable_thresholds
+                  threshold = variable_threshold(group.desired_capacity, @n_low, @n_high, @m, @g_low, @g_high)
+
+                  stats = vt_cpu_alarm.metric.statistics(
+                    :start_time => Time.now - (vt_cpu_alarm.period * vt_cpu_alarm.evaluation_periods),
+                    :end_time => Time.now,
+                    :statistics => [ vt_cpu_alarm.statistic ],
+                    :period => vt_cpu_alarm.period)
+
+                  if stats.datapoints.length < vt_cpu_alarm.evaluation_periods
+                    hlog("Could not get enough datapoints for checking variable threshold");
+                    next
+                  end
+
+                  if stats.datapoints.any? {|dp| dp[vt_cpu_alarm.statistic.downcase.to_sym] > (threshold * 100) }
+                    hlog("Not all datapoints are beneath the variable threshold #{(threshold * 100).to_i}: #{stats.datapoints}")
+                    next
+                  end
+                end
+
+                outside_cooldown = outside_cooldown_period(group)
                 unless outside_cooldown_period(group)
                   hlog("Group is not outside the specified cooldown periods")
                   next
@@ -69,8 +143,12 @@ module Vector
                   next
                 end
 
-                hlog("Executing policy")
-                policy.execute(:honor_cooldown => true)
+                if @dry_run
+                  hlog("Executing policy (DRY RUN)")
+                else
+                  hlog("Executing policy")
+                  policy.execute(:honor_cooldown => true)
+                end
 
                 result[:triggered] = true
 
@@ -86,6 +164,15 @@ module Vector
 
       protected
 
+      def variable_threshold(n, n_low, n_high, m, g_low, g_high)
+        m_high = g_high * m
+        m_low = g_low * m
+        a = (m_high - m_low).to_f / (n_high - n_low).to_f
+        b = m_low - (n_low * a)
+        res = (a * n + b) * (1.0 - (1.0 / n))
+        res
+      end
+
       def has_eligible_scaledown_instance(group)
         return true if @max_sunk_cost.nil?
 

data/lib/vector/functions/predictive_scaling.rb

@@ -5,6 +5,7 @@ module Vector
 
       def initialize(options)
         @cloudwatch = options[:cloudwatch]
+        @dry_run = options[:dry_run]
         @lookback_windows = options[:lookback_windows]
         @lookahead_window = options[:lookahead_window]
         @valid_threshold = options[:valid_threshold]
@@ -83,8 +84,12 @@ module Vector
                         result[:check_procs] << check_proc
 
                         if check_proc.call(now_num)
-                          hlog "Executing policy"
-                          policy.execute(honor_cooldown: true)
+                          if @dry_run
+                            hlog "Executing policy (DRY RUN)"
+                          else
+                            hlog "Executing policy"
+                            policy.execute(honor_cooldown: true)
+                          end
 
                           result[:triggered] = true
 

data/lib/vector/version.rb

@@ -1,3 +1,3 @@
 module Vector
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: vector
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.5
 platform: ruby
 authors:
 - Zach Wily
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-21 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   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: aws-asg-fleet
   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: activesupport
   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: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   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: 
@@ -99,7 +88,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -114,27 +103,26 @@ files:
 homepage: http://github.com/instructure/vector
 licenses:
 - MIT
+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: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: AWS Auto-Scaling Assistant
 test_files: []
 has_rdoc: