as-combined-metrics 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6db99eeeb56b6107fd4f3e98aee2043f3addb23d
+  data.tar.gz: 84ad3a6ce0b4bd2840c30829045769e2fa95c6cd
+SHA512:
+  metadata.gz: 25583029dc0e54184705bb798f9649bd73c04c2f2d0bc9136b9e7ecd177a3a9dd199785386731bb75b89ba5c49158704ecabfae722fdf619127588fc0d785e4e
+  data.tar.gz: ed23784918bf5407ea352a9c5cd591ddc6f28c0796e270f2d396b5f2e279695347c7ed042b45a9b1d177a19071659a6e7688dddbecf0037234cd53e539f620bd

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+*.conf
+combinedMetrics.yml
+*.bkpgit pu

data/AsCombinedMetrics.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+$:.push File.expand_path("../lib/as-combined-metrics", __FILE__)
+
+require File.expand_path('../lib/as-combined-metrics', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "as-combined-metrics"
+  s.version     = AsCombinedMetrics::VERSION
+  s.authors     = ["Ami Mahloof"]
+  s.email       = "ami.mahloof@gmail.com"
+  s.homepage    = "https://github.com/innovia/as-combined-metrics"
+  s.summary     = "Submit custom AWS CloudWatch metric that combines several other thresholds for scale in or out"
+  s.description = "AWS custom combined metric CloudWatch tool"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files = `git ls-files`.split($\).reject{|n| n =~ %r[png|gif\z]}.reject{|n| n =~ %r[^(test|spec|features)/]}
+  s.add_runtime_dependency 'thor', '~> 0.19', '>= 0.19.1'
+  s.add_runtime_dependency 'aws-sdk', '~> 2.0.45', '>= 2.0.45'
+  s.add_runtime_dependency 'activesupport', '~> 4.2.3', '>= 4.2.3'
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.extra_rdoc_files = ['README.md', 'LICENSE']
+  s.license = 'MIT'
+end

data/CHANGES.md

@@ -0,0 +1,2 @@
+1.0.0
+initial release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Glide Talk, LTD.
+
+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,152 @@
+AWS Autoscale Combined Metrics
+==============================
+
+Beta - Not Production Ready!
+
+AWS currently (July 2015) does not evalute other policies during a cooldown peroid
+
+meanning if CPU policy was triggered and scaling acitivty happened the other policies for Network / Memory etc.. would not be evaluated until the cooldown period for the first policy passed
+
+this gem will push a custom metric to cloudwatch:
+
+it will combine the metrics you want to check and only if all of them are out of the treshold you provided 
+
+scale in if *all* metrics are in range send a 1 (ok to scale in)
+scale out if *any* metrics are in range send a 1 (ok to scale out)
+
+How it works
+------------
+
+There's a yml config file in which you specify either a cloudformation stack name and resource (i.e AppServerGroup)
+in this config you specify the metrics tresholds and comparison operator to evalute (kind of alrams in CloudWatch)
+
+you can specify sectaions for ScaleOut and ScaleIn and their related metrics in the config file
+
+````yml
+ScaleOut:
+- metric_name: CPUUtilization
+  namespace: AWS/EC2
+  statistics:
+  - Maximum
+  unit: Percent
+  threshold: 20
+  comparison_operator: <=
+  aggregate_as_group: true
+````
+
+you can specify aggregate_as_group: true in the config and it will aggregate based on the statistics you passed across ec2 instances
+
+Note:
+AWS is already agregating the instances metrics on the AutoScaleGroupName dimension for you (so if you are pushing a custom metrics you shold be pushing it to the autoscale group diemension)
+
+
+if the autoscale group needs to be extracted from the stack name you specify (useful for discovery uisng cloudformation)
+````yml
+cloudformation:
+  enabled: true
+  stack_name: STACK_NAME_X
+  logical_resource_ids: 
+  - CloudFormation_RESOURCE_ID 
+````
+
+The app will combined the results of all metrics into a true / flase array
+for ScaleOut events it will check if any element in the array is true and will publish a custom metric (i.e ScaleOut_CPUUtilization_NetworkIn ) under the combined_metrics custom name space in CloudWatch on the AutoScale Group dimension you have specified in the config
+
+you can then set a single alarm and a single policy to perform your scale activity if itsthe value is 1 (O.K to scale in/out)
+
+
+you run the file through the as-combined-metrics app (a backup of the config will be created)
+
+````bash
+as-combined-metrics -f path_to/combinedMetrics.yml
+````
+
+options:
+--------
+````bash
+  r, [--region=REGION]                 # AWS Region
+                                       # Default: us-east-1
+  l, [--log-level=LOG_LEVEL]           # Log level
+                                       # Default: INFO
+  f, [--config-file=CONFIG_FILE]       # Metrics config file location
+      [--scalein-only=SCALEIN_ONLY]    # gather combined metrics for scale in only
+      [--scaleout-only=SCALEOUT_ONLY]  # gather combined metrics for scale out only
+  p, [--period=N]                      # Metric datapoint last x minutes
+                                       # Default: 300
+  t, [--timeout=N]                     # Timeout (seconds) for fetching autoscale group name
+                                       # Default: 120
+  o, [--once], [--no-once]             # no loop - run once
+  d, [--dryrun], [--no-dryrun]         # do not submit metric to CloudWatch
+  i, [--interval=N]                    # interval to check metrics
+                                       # Default: 30
+````
+ 
+Required privileges
+-------------------
+
+* cloudwatch:GetMetricStatistics
+* cloudwatch:PutMetricData
+* autoscaling:DescribeAutoScalingGroups
+* cloudformation:DescribeStackResources
+* cloudformation:DescribeStacks
+
+policy sample
+````json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "Stmt1436799375000",
+            "Effect": "Allow",
+            "Action": [
+                "cloudwatch:GetMetricStatistics",
+                "cloudwatch:PutMetricData"
+            ],
+            "Resource": [
+                "*"
+            ]
+        },
+        {
+            "Sid": "Stmt1436799403000",
+            "Effect": "Allow",
+            "Action": [
+                "autoscaling:DescribeAutoScalingGroups"
+            ],
+            "Resource": [
+                "*"
+            ]
+        },
+        {
+            "Sid": "Stmt1436799495000",
+            "Effect": "Allow",
+            "Action": [
+                "cloudformation:DescribeStackResources",
+                "cloudformation:DescribeStacks"
+            ],
+            "Resource": [
+                "*"
+            ]
+        }
+    ]
+}
+````
+
+Credentials are loaded automatically from the following locations (AWS-SDK handled):
+
+* ENV['AWS_ACCESS_KEY_ID'] and ENV['AWS_SECRET_ACCESS_KEY']
+* Aws.config[:credentials]
+* Shared credentials file, ~/.aws/credentials
+* EC2 Instance profile
+
+
+Contributing
+-------------
+1. Fork it
+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 new Pull Request
+
+License
+-------
+aws-cobined-metrics is released under [MIT License](http://www.opensource.org/licenses/MIT)

data/bin/as-combined-metrics

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+require 'thor'
+require 'as-combined-metrics'
+require 'active_support/hash_with_indifferent_access'
+
+def help
+  AsCombinedMetrics::Cli.help(Thor::Base.shell.new) 
+end
+
+
+begin
+  ENV["THOR_DEBUG"] = "1" 
+  AsCombinedMetrics::Cli.start
+rescue Thor::RequiredArgumentMissingError => e
+  puts "\e[31mMissing Arguments: #{e}\e[0m\n\n"
+  help
+rescue Thor::InvocationError => e
+  puts "\e[31m#{e.to_s.gsub(/Usage:.+"/, '').chomp} but there's no such option\e[0m\n\n"
+  help
+end
+
+

data/combinedMetrics-sample.yml

@@ -0,0 +1,56 @@
+---
+cloudformation:
+  enabled: true
+  stack_name: STACK_NAME_X
+  logical_resource_ids: 
+  - CloudFormation_RESOURCE_ID 
+
+autoscale_group_name: GROUP_NAME-X
+
+ScaleIn:
+- metric_name: CPUUtilization
+  namespace: AWS/EC2
+  statistics:
+  - Maximum
+  unit: Percent
+  threshold: 20
+  comparison_operator: <=
+- metric_name: NetworkIn
+  namespace: AWS/EC2
+  unit: Bytes
+  threshold: 188743680
+  statistics:
+  - Maximum
+  comparison_operator: <=
+- metric_name: memory_usage.heapUsed.max
+  namespace: node_cluster
+  statistics:
+  - Average
+  unit: Bytes
+  threshold: 7864320
+  comparison_operator: <=
+  aggregate_as_group: true
+
+
+ScaleOut:
+- metric_name: CPUUtilization
+  namespace: AWS/EC2
+  statistics:
+  - Maximum
+  unit: Percent
+  threshold: 20
+  comparison_operator: <=
+- metric_name: NetworkIn
+  namespace: AWS/EC2
+  unit: Bytes
+  threshold: 188743680
+  statistics:
+  - Maximum
+  comparison_operator: <=
+- metric_name: memory_usage.heapUsed.max
+  namespace: node_cluster
+  statistics:
+  - Average
+  unit: Bytes
+  threshold: 7864320
+  comparison_operator: <=

data/lib/as-combined-metrics/aws.rb

@@ -0,0 +1,42 @@
+module AsCombinedMetrics::Cli::Aws
+	def init_aws_sdk
+		logger.progname = "#{Module.nesting.first.to_s} init_aws_sdk"
+    logger.info { set_color  "Initializing AWS SDK", :white }
+    
+    Aws.config.update({region: options[:region]})
+
+    # add max retries
+    @cw  = Aws::CloudWatch::Client.new()
+    @cfm = Aws::CloudFormation::Client.new()
+    @as  = Aws::AutoScaling::Client.new()  
+  end
+
+  def validate_as_group(autoscale_group_name)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+    logger.info { set_color "Validating #{autoscale_group_name} exists...", :white }
+ 
+    response =  @as.describe_auto_scaling_groups({auto_scaling_group_names: [autoscale_group_name], max_records: 1})
+
+    if response.auto_scaling_groups.empty? || autoscale_group_name != response.auto_scaling_groups[0].auto_scaling_group_name
+      logger.fatal { set_color "Can't find AutoScale group #{autoscale_group_name} on ec2 - exiting now", :red }
+      exit 1
+    else
+      logger.info { set_color "O.K", :green }
+    end
+  end
+  
+  def verify_stack_name
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    if ENV['STACK_NAME']
+      logger.info { set_color "STACK_NAME Env variable was found [ #{ENV['STACK_NAME']} ]", :cyan }
+      @stack_name = ENV['STACK_NAME']
+    elsif @config["cloudformation"]["stack_name"]
+      logger.info { set_color "STACK_NAME was found in the config file #{@config["cloudformation"]["stack_name"]}", :cyan }
+      @stack_name = @config["cloudformation"]["stack_name"]
+    else
+      logger.fatal { set_color "verify_stack_name_env Env variable STACK_NAME was not found or does not have a value, exiting now...", :red }
+      exit 1  
+    end
+  end
+end

data/lib/as-combined-metrics/cli.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'thor'
+require 'aws-sdk'
+require 'yaml'
+require 'pp'
+require 'time'
+
+class AsCombinedMetrics::Cli < Thor
+  autoload :Logging,        'as-combined-metrics/logger'
+  autoload :Config,         'as-combined-metrics/config'
+  autoload :Poller,         'as-combined-metrics/poller'
+  autoload :Aws,            'as-combined-metrics/aws'
+  autoload :Utils,          'as-combined-metrics/utils'
+  autoload :Stats,          'as-combined-metrics/stats'
+  autoload :CloudWatch,     'as-combined-metrics/cloudwatch'
+  autoload :CloudFormation, 'as-combined-metrics/cloudformation'
+
+  default_task  :start
+
+  class_option  :region,              :desc => 'AWS Region',                                          :default => 'us-east-1',      :aliases => 'r', :type => :string
+  class_option  :log_level,           :desc => 'Log level',                                           :default => 'INFO',           :aliases => 'l', :type => :string
+  class_option  :config_file,         :desc => 'Metrics config file location',                                                      :aliases => 'f', :type => :string
+  class_option  :scalein_only,        :desc => 'gather combined metrics for scale in only',           :default => false
+  class_option  :scaleout_only,       :desc => 'gather combined metrics for scale out only',          :default => false
+  class_option  :period,              :desc => 'Metric datapoint last x minutes',                     :default => 300,              :aliases => 'p', :type => :numeric
+  class_option  :timeout,             :desc => 'Timeout (seconds) for fetching autoscale group name', :default => 120,              :aliases => 't', :type => :numeric
+  class_option  :once,                :desc => "no loop - run once",                                  :default => false,            :aliases => 'o', :type => :boolean
+  class_option  :dryrun,              :desc => "do not submit metric to CloudWatch",                  :default => false,            :aliases => 'd', :type => :boolean
+  class_option  :interval,            :desc => 'interval to check metrics',                           :default => 30,               :aliases => 'i', :type => :numeric
+  desc "start", "combine metrics"
+  def start
+    %w(INT TERM USR1 USR2 TTIN).each do |sig|
+      trap sig do
+        puts "Got Singnal #{sig} Exiting..."
+        exit 0
+      end
+    end
+    
+    raise Thor::RequiredArgumentMissingError, 'missing config file location [-f / --config-file]' if options[:config_file].nil?
+
+    extend Logging
+    extend Utils
+    extend Config
+    extend Stats
+    extend Aws
+    extend CloudFormation
+    extend CloudWatch
+    extend Poller
+    
+    logger.info { set_color "Dry Run - will not published metrics to CloudWatch", :yellow } if options[:dryrun]
+    logger.info "Starting Combined Metrics on #{options[:region]} region"
+    init_aws_sdk
+    load_config
+    poll(options[:interval])
+    <<-INFO 
+        1) in this loop (poll) we overwrite a hash of combined metrics as follow:
+
+           for every metric in the config file use fetch_metric(metric) to get it's current reading
+           
+           if metric has a key of aggregate_as_group, 
+              get all instances of the AutoScale group and for each instance fetch metric 
+              then push the result to an array, from that array get the average result and push it to the combined_metrics hash
+
+           if one of the metrics fails to get datapoints (result => empty datapoints set) then set the result to -1
+           the check_combined_metrics will see that the value is -1 and automatically false the result  
+
+        
+        Combined metrics: 
+        { "CPUUtilization" => {"measure"=>7.08, "threshold"=>30, "comparison_operator"=>">="}, 
+          "NetworkIn" => {"measure"=>43765341.0, "threshold"=>943718400, "comparison_operator"=>">="},
+          "memory_usage.heapUsed.average"=>{"measure"=> 67844551, "threshold"=>600000, "comparison_operator"=>">="}
+        }
+
+        2) we then call check_combined_metrics to check if the measure is under or above the threshold and the result (true/false) to array
+        
+        3) if all elements of that array are true we set the value of self.combined_metric_value to 1 (Scale OK) else we set it to 0 (Do not Scale)
+
+        4) last step -> publish that value to CloudWatch
+    INFO
+  end
+
+  map ["-v", "--version"] => :version
+  desc "version", "version"
+  def version
+    say AsCombinedMetrics::ABOUT, color = :green
+  end  
+end

data/lib/as-combined-metrics/cloudformation.rb

@@ -0,0 +1,46 @@
+module AsCombinedMetrics::Cli::CloudFormation
+  def describe_stack(logical_resource_id)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    logger.info { set_color  "Getting the full autoscale group name for the resource => #{logical_resource_id}", :white }
+    counter = 1
+    @autoscale_group_name = nil
+    @print_log = true
+
+    until @autoscale_group_name
+      begin
+        stack_info = @cfm.describe_stack_resource({
+          :stack_name => @stack_name, 
+          :logical_resource_id => logical_resource_id
+        })
+
+        if !stack_info.nil?
+          @autoscale_group_name = stack_info.stack_resource_detail.physical_resource_id
+          @config["autoscale_group_name"] = @autoscale_group_name
+          File.open(options[:config_file], "w") { |f| f.write(@config.to_yaml) }
+          logger.info { set_color  "AutoScale Group Name: #{@autoscale_group_name}", :cyan }
+        end
+      rescue Exception => e
+        if e.to_s.match (/Stack with name\s\S+\sdoes not exist/)
+          logger.fatal { set_color "Stack name was not found", :red }
+          exit 1
+        end
+
+        if @print_log
+          logger.error { set_color  "Unable to find the resource - #{e}", :yellow }
+          logger.info { "Will retry every 5 seconds up to maximum of #{options[:timeout]} seconds" } 
+        end
+
+        interval = 5
+        if counter < options[:timeout].to_i
+          counter += interval
+          @print_log = false
+          sleep interval
+        else
+          logger.fatal { set_color  "Timeout Error  - Unable to get the full AutoScale group name for the stack #{@stack_name} for #{options[:timeout]} seconds", :red }
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/as-combined-metrics/cloudwatch.rb

@@ -0,0 +1,70 @@
+module AsCombinedMetrics::Cli::CloudWatch
+  
+  def set_default_options(hash, member)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+    if hash[member] && !hash[member].nil?
+      default = hash[member]
+    else
+      default =  self.config["default_options"][member.to_s.gsub("_", "-")] if !self.config["default_options"][member.to_s.gsub("_", "-")].nil?
+    end
+  end
+
+  def fetch_metric(metric)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    # Read from CloudWatch  
+    data = {
+        :start_time => (Time.now.utc - options[:period]).iso8601,
+        :end_time   => (Time.now.utc).iso8601,
+        :period     => options[:period]
+    }
+
+    # # removing the keys that are not used in fetch metric 
+    metric = metric.merge(data).reject { |k,v| [:comparison_operator, :threshold, :aggregate_as_group].include? k }
+    
+    logger.info { set_color "Polling data for metric: #{metric[:metric_name]}", :white }
+    logger.info { "Metric info: #{metric}" }
+    
+    begin
+      result = @cw.get_metric_statistics(metric).to_hash
+    rescue Exception => e
+      logger.error { set_color "An error occured #{e}, SDK will retry", :red }
+    end
+
+    if result[:datapoints].empty?
+      logger.info { set_color "No datapoints found for #{metric[:metric_name]} - Will publish a value of 0 (Don't DownScale) to CloudWatch", :red }
+      logger.info { "Result: #{result}" }
+      return -1
+    else
+      datapoint = result[:datapoints][0][metric[:statistics][0].downcase.to_sym]
+      logger.info { set_color "Result: #{datapoint} #{result[:datapoints][0][:unit]}", :white }
+      datapoint
+    end
+  end
+
+  def publish_metric(mode, combined_metric_value)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    cw_options = {
+      namespace: 'combined_metrics',
+      metric_data: [
+        metric_name: combined_metrics_name(mode),
+         dimensions: [{
+          name: 'AutoScalingGroupName',
+          value: @config[:autoscale_group_name]
+        }],
+        value: combined_metric_value,
+        unit: 'None'
+      ]
+    }
+    logger.info { set_color "Options to be sent to cloudwatch: #{cw_options}", :white }
+    
+    begin
+      logger.info { set_color "Publishing Combined Metrics to CloudWatch...", :white }
+      @cw.put_metric_data(cw_options)      
+    rescue Exception => e
+      logger.error { set_color "An error occured #{e}, SDK will retry up to 3 times", :red }
+    end
+  end
+
+end

data/lib/as-combined-metrics/config.rb

@@ -0,0 +1,64 @@
+require 'digest/sha1'
+
+class ConfigError < StandardError
+end
+
+module AsCombinedMetrics::Cli::Config
+  def load_config
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+    raise ConfigError, "Config file not found" if !File.exists?(options[:config_file])
+
+    sha1_config = Digest::SHA1.hexdigest(File.read(options[:config_file]))
+
+    if File.exists?("#{options[:config_file]}.bkp")
+      sha1_config_bkp = Digest::SHA1.hexdigest(File.read("#{options[:config_file]}.bkp")) 
+    else
+      sha1_config_bkp = nil
+    end
+
+    if sha1_config != sha1_config_bkp
+      logger.info { set_color  "Backing up original config file to #{options[:config_file]}.bkp", :white }
+      FileUtils.cp(options[:config_file], "#{options[:config_file]}.bkp")  
+    else
+      logger.info {set_color "Skipping backup because the backup is identical to the config file", :white }
+    end
+
+    begin
+      logger.info { set_color "Loading config file (#{options[:config_file]})", :white }
+      @config = YAML.load_file(options[:config_file])
+
+      # Symbolize keys recursively for config
+      @config.deep_symbolize_keys!
+      logger.debug "config: #{@config}"
+      
+      if options[:scalein_only] && !@config.has_key?(:ScaleIn)
+        raise ConfigError, "Could not find the proper mode for ScaleIn in the config file"
+      elsif options[:scaleout_only] && !@config.has_key?(:ScaleOut)
+        raise ConfigError, "Could not find the proper mode for ScaleOut in the config file"
+      elsif !@config.has_key?(:ScaleIn) || !@config.has_key?(:ScaleOut)
+        raise ConfigError, "Could not find the proper mode for ScaleIn or ScaleOut in the config file"
+      end
+
+    rescue Exception, ConfigError => e
+      logger.fatal {set_color "Error reading config file: #{e}", :red}
+      puts e.backtrace
+      exit 1
+    end
+    process
+  end
+
+  def process
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    if @config.has_key?(:autoscale_group_name)
+      validate_as_group(@config[:autoscale_group_name])
+    elsif @config[:cloudformation][:enabled]
+      verify_stack_name
+
+      @config[:cloudformation][:logical_resource_ids].each do | resource |
+        logger.debug "logical_resource_id: #{resource}"
+        describe_stack(resource)
+      end
+    end
+  end
+end

data/lib/as-combined-metrics/logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module AsCombinedMetrics::Cli::Logging
+  def logger
+    @logger ||= AsCombinedMetrics::Cli::Logging.logger_for(self.class.name, options[:log_level])
+  end
+
+  # Use a hash class-ivar to cache a unique Logger per class:
+	@loggers = {}
+		
+  class << self 
+    def logger_for(class_name, level)
+      @loggers[class_name] ||= configure_logger_for(level)
+    end
+
+    def configure_logger_for(level)
+      logger = Logger.new(STDOUT)
+      logger.level = Object.const_get("Logger::#{level.upcase}")
+      logger
+    end
+  end
+end
+
+

data/lib/as-combined-metrics/poller.rb

@@ -0,0 +1,51 @@
+module AsCombinedMetrics::Cli::Poller
+  def poll(interval)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+    @combined_metrics = {}
+    
+    if options[:scalein_only]
+      modes = [:ScaleIn]
+    elsif  options[:scaleout_only]
+      modes = [:ScaleOut]
+    else
+      modes = [:ScaleIn, :ScaleOut]
+    end
+
+    loop do
+      modes.each do |mode|
+        logger.info "Polling metrics for #{mode}"
+        
+        @config[mode].each do |metric|
+          logger.debug "Getting stats for metric #{metric}"
+          @combined_metrics[metric[:metric_name]] ||= {}
+          
+          if metric.has_key?(:aggregate_as_group)
+            logger.debug "Aggregating autoscale group metrics"
+            @combined_metrics[metric[:metric_name]][:measure] = aggregate_instances_per_as_group(metric)
+          else
+            metric[:dimensions] = [{ name: "AutoScalingGroupName", value: @config[:autoscale_group_name]}]
+            @combined_metrics[metric[:metric_name]][:measure] = fetch_metric(metric) unless @combined_metrics[metric[:metric_name]].has_key?(:measure)
+          end
+        
+          @combined_metrics[metric[:metric_name]][:threshold] = metric[:threshold]
+          @combined_metrics[metric[:metric_name]][:comparison_operator] = metric[:comparison_operator]
+        end
+      
+        logger.info { set_color  "Combined metrics attributes for #{mode}: #{@combined_metrics}", :cyan }
+        combined_metric_value = check_combined_metrics(mode)
+        
+        logger.info { set_color "Combined metrics value: #{combined_metric_value} => [0 = Do Not #{mode}, 1 = OK To #{mode}]" }
+
+        publish_metric(mode, combined_metric_value)  unless options[:dryrun]
+        end
+        
+        if options[:once]
+          logger.info { set_color "Ran Once - Exiting now..." }
+          exit 0
+        else
+          logger.info { set_color "Next metrics check in #{interval} seconds..." }
+          sleep interval
+        end
+     end
+  end
+end

data/lib/as-combined-metrics/stats.rb

@@ -0,0 +1,98 @@
+module AsCombinedMetrics::Cli::Stats
+  def check_combined_metrics(mode)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    logger.info { set_color "Checking combined metrics for #{mode}:", :white }
+    
+    # prepare an array to hold a true / false result for each metric
+    results_array = []
+    
+    # checking each metric by its comparison operator for true / flase
+    @combined_metrics.each do |name, values|
+      # The line below checks => measure comparison operator value (a <= b) without the use of eval! (it turn the string into evalutation)
+      # measure.method(b['comparison_operator']).(threshold)
+      if values[:measure] == -1
+        evaluation = false
+      else
+        evaluation = values[:measure].method(values[:comparison_operator]).(values[:threshold])
+      end
+      results_array << evaluation
+      logger.info { set_color "Results for combined metrics for #{name} with #{values}: #{results_array.last}", :magenta }
+    end
+
+    # a short hand if statement =>  if all array elements true set combined_metric_value to 1 else to 0
+    case mode 
+    when :ScaleIn then
+      results_array.all? ?  combined_metric_value = 1 :  combined_metric_value  = 0
+    when :ScaleOut then
+      results_array.any? ?  combined_metric_value = 1 :  combined_metric_value  = 0
+    else
+      logger.fatal { set_color "Could not find mode #{mode} - check the config file, exiting now...", :red }
+      exit
+    end
+      
+    logger.info { set_color "Combined results of #{results_array} for #{mode} is: #{combined_metric_value}", :yellow, :bold }
+
+    return combined_metric_value
+  end
+
+  def aggregate_instances_per_as_group(metric)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+    logger.info { set_color "Aggregating metrics accross instances for autoscale group: #{@config[:autoscale_group_name]}" , :white}
+    begin
+
+      instances =  @as.describe_auto_scaling_groups({auto_scaling_group_names: [@config[:autoscale_group_name]], max_records: 1}).auto_scaling_groups.first.instances.collect {|i| i[:instance_id]}
+
+      logger.info { set_color "Found #{instances.size} Instances for autoscale group: #{@config['autoscale_group_name']}", :magenta }
+      
+      instances_aggregated_data = []
+      
+      metric[:dimensions] = [{name: "InstanceId"}]
+
+      instances.each do |instance_id|
+        metric[:dimensions][0][:value] = instance_id
+
+        logger.info {"aggregated metric: #{metric}"}
+        metric_result = fetch_metric(metric)
+
+        logger.info { set_color "Metric result: #{metric_result}", :bold }
+
+        if metric_result == -1
+          instances_aggregated_data << metric_result
+          break
+          return # check removal of break
+        else
+          instances_aggregated_data << metric_result
+        end
+      end
+
+      logger.info { "Instances_aggregated_data: #{instances_aggregated_data}"  }
+      
+      if !instances_aggregated_data.empty?
+        case metric[:statistics][0].downcase
+        when 'maximum'
+          logger.info { set_color "Instances_aggregated_data [Maximum]: #{instances_aggregated_data.max}", :yellow }
+          instances_aggregated_data.max
+        when 'minimum'
+          logger.info { set_color "Instances_aggregated_data [Minimum]: #{instances_aggregated_data.min}", :yellow }
+          instances_aggregated_data.min
+        else
+          avg_array(instances_aggregated_data)
+        end
+      else
+        # Do not scale down - we don't have all the metric data to scale down
+      end
+    rescue Exception => e
+      logger.info { set_color "Error aggregating metrics #{e.message}", :red }
+    end
+  end
+
+  def avg_array(data)
+    logger.progname = "#{Module.nesting.first.to_s} #{__method__}"
+
+    avg = (data.inject {|sum, i| sum + i }) / data.size
+    self.logger.info { set_color "Instances_aggregated_data [Average]: #{avg.round}", :white }
+    avg.round 
+  end
+
+end

data/lib/as-combined-metrics/utils.rb

@@ -0,0 +1,6 @@
+module AsCombinedMetrics::Cli::Utils
+  def combined_metrics_name(mode)
+    # combined the metrics name for each mode with underscores
+    "#{mode}_#{@config[mode].map { |m| m[:metric_name].gsub(/\.|-/, '_')}.join('_')}"
+  end
+end

data/lib/as-combined-metrics.rb

@@ -0,0 +1,8 @@
+module AsCombinedMetrics
+  VERSION   = "1.0.0"
+  ABOUT     = "as-combined-metrics v#{VERSION} (c) #{Time.now.strftime("2015-%Y")} @innovia"
+
+  $:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+  autoload :Cli,      'as-combined-metrics/cli'
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: as-combined-metrics
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ami Mahloof
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.45
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.45
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.45
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.45
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.3
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.3
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.3
+description: AWS custom combined metric CloudWatch tool
+email: ami.mahloof@gmail.com
+executables:
+- as-combined-metrics
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- .gitignore
+- AsCombinedMetrics.gemspec
+- CHANGES.md
+- LICENSE
+- README.md
+- bin/as-combined-metrics
+- combinedMetrics-sample.yml
+- lib/as-combined-metrics.rb
+- lib/as-combined-metrics/aws.rb
+- lib/as-combined-metrics/cli.rb
+- lib/as-combined-metrics/cloudformation.rb
+- lib/as-combined-metrics/cloudwatch.rb
+- lib/as-combined-metrics/config.rb
+- lib/as-combined-metrics/logger.rb
+- lib/as-combined-metrics/poller.rb
+- lib/as-combined-metrics/stats.rb
+- lib/as-combined-metrics/utils.rb
+homepage: https://github.com/innovia/as-combined-metrics
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Submit custom AWS CloudWatch metric that combines several other thresholds
+  for scale in or out
+test_files: []