sensu-plugins-aws-boutetnico 1.0.6

data/bin/check-asg-instances-created.rb

@@ -0,0 +1,129 @@
+#! /usr/bin/env ruby
+#
+# check-asg-instance-created
+#
+# DESCRIPTION:
+#   Check AutoScalingGroup Instances are Terminated & Launching last hour.
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   all AutoScalingGroup
+#   ./check-asg-instance-created -r ${your_region}
+#   one AutoScalingGroup
+#   ./check-asg-instance-created -r ${your_region} -g 'AutoScalingGroupName'
+#
+# NOTES:
+#   Based heavily on Peter Hoppe check-asg-instance-created
+#
+# LICENSE:
+#   Peter Hoppe <peter.hoppe.extern@bertelsmann.de>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'aws-sdk'
+require 'sensu-plugins-aws'
+
+class CheckAsgInstanceCreated < Sensu::Plugin::Check::CLI
+  include Common
+  option :aws_region,
+         short:       '-r AWS_REGION',
+         long:        '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default:     ENV['AWS_REGION']
+
+  option :asg_group_name,
+         short:       '-g G',
+         long:        '--asg_group_name AutoScalingGroupName',
+         description: 'AutoScalingGroupName to check'
+
+  option :warning_limit,
+         short:       '-w W',
+         long:        '--warning_limit Warning Limit',
+         description: 'Warning Limit for launching and terminated instances',
+         proc: proc(&:to_i)
+
+  option :critical_limit,
+         short:       '-c C',
+         long:        '--critical_limit Critical Limit',
+         description: 'Critical Limit for launching and terminated instances',
+         proc: proc(&:to_i)
+
+  def asg
+    @asg = Aws::AutoScaling::Client.new
+  end
+
+  def describe_activities(asg_group_name)
+    asg.describe_scaling_activities(
+      auto_scaling_group_name: asg_group_name.to_s
+    )
+  end
+
+  def run
+    warning = 3
+    critical = 4
+    result_launched = ''
+    result_terminated = ''
+    instance_launching = 0
+    instance_terminating = 0
+    time_now = Time.now
+    time_utc_offset = time_now - time_now.utc_offset
+
+    if !config[:warning_limit].nil?
+      warning = config[:warning_limit]
+    elsif !config[:critical_limit].nil?
+      critical = config[:critical_limit]
+    end
+
+    if config[:asg_group_name].nil?
+      asg.describe_auto_scaling_groups.auto_scaling_groups.each do |asg_group|
+        describe_activities(asg_group.auto_scaling_group_name).each do |activities|
+          activities.activities.each do |activity|
+            if Time.parse(activity.start_time.inspect) > (time_utc_offset - 3600)
+              if activity.description.include? 'Launching'
+                instance_launching += 1
+                result_launched = " #{instance_launching} Instances Launching in AutoScalingGroup #{asg_group.auto_scaling_group_name}"
+              elsif activity.description.include? 'Terminating'
+                instance_terminating += 1
+                result_terminated = " #{instance_terminating} Instances Terminated in AutoScalingGroup #{asg_group.auto_scaling_group_name}"
+              end
+            end
+          end
+        end
+      end
+    else
+      describe_activities(config[:asg_group_name]).each do |activities|
+        activities.activities.each do |activity|
+          if Time.parse(activity.start_time.inspect) > (time_utc_offset - 3600)
+            if activity.description.include? 'Launching'
+              instance_launching += 1
+              result_launched = " #{instance_launching} Instances Launching in AutoScalingGroup #{config[:asg_group_name]}"
+            elsif activity.description.include? 'Terminating'
+              instance_terminating += 1
+              result_terminated = " #{instance_terminating} Instances Terminated in AutoScalingGroup #{config[:asg_group_name]}"
+            end
+          end
+        end
+      end
+    end
+    if instance_terminating.zero? && instance_launching.zero?
+      ok 'No instances Launched & Terminated last hour'
+    elsif instance_terminating >= critical && instance_launching >= critical
+      critical "#{result_launched} \n #{result_terminated}"
+    elsif instance_terminating >= warning && instance_launching >= warning
+      warning "#{result_launched} \n #{result_terminated}"
+    else
+      ok "#{result_launched} \n #{result_terminated}"
+    end
+  end
+end

data/bin/check-asg-instances-inservice.rb

@@ -0,0 +1,109 @@
+#! /usr/bin/env ruby
+#
+# check-autoscaling-instances-inservice
+#
+# DESCRIPTION:
+#   Check AutoScaling Instances inService.
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   ./check-autoscaling-instances-inservices.rb -r ${your_region}
+#   one autoScalingGroup
+#   ./check-autoscaling-instances-inservices.rb -r ${your_region} -g 'autoScalingGroupName'
+#
+# NOTES:
+#   Based heavily on Yohei Kawahara's check-ec2-network
+#
+# LICENSE:
+#   Peter Hoppe <peter.hoppe.extern@bertelsmann.de>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-aws'
+require 'sensu-plugin/check/cli'
+require 'aws-sdk'
+
+class CheckAsgInstancesInService < Sensu::Plugin::Check::CLI
+  include Common
+  option :aws_region,
+         short:       '-r AWS_REGION',
+         long:        '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default:     ENV['AWS_REGION']
+
+  option :group,
+         short:       '-g G',
+         long:        '--autoscaling-group GROUP',
+         description: 'AutoScaling group to check'
+
+  def asg
+    @asg ||= Aws::AutoScaling::Client.new
+  end
+
+  def describe_asg(asg_name)
+    asg.describe_auto_scaling_groups(
+      auto_scaling_group_names: [asg_name.to_s]
+    )
+  end
+
+  def run
+    warning = 0
+    critical = 0
+    instance_in_service = 0
+    result = ''
+    if config[:group].nil?
+      asg.describe_auto_scaling_groups.auto_scaling_groups.each do |group|
+        grp_name = group.auto_scaling_group_name
+        instance_in_service = 0
+        group.instances.each do |instance|
+          if instance.lifecycle_state == 'InService'
+            instance_in_service += 1
+          end
+        end
+        if instance_in_service.zero?
+          critical = 1
+          result += "#{grp_name}: no Instances inService  #{instance_in_service} \n"
+        elsif instance_in_service < group.min_size
+          warning = 1
+          result += "#{grp_name} Intance are not okay #{instance_in_service} \n"
+        else
+          result += "#{grp_name} Intance are inService #{instance_in_service} \n"
+        end
+      end
+    else
+      selected_group = describe_asg(config[:group])[0][0]
+      min_size = selected_group.min_size
+      selected_group.instances.each do |instance|
+        if instance.lifecycle_state == 'InService'
+          instance_in_service += 1
+        end
+      end
+      if instance_in_service.zero?
+        critical = 1
+        result += "#{config[:group]}: no Instances inService  #{instance_in_service} \n"
+      elsif instance_in_service < min_size
+        warning = 1
+        result += "#{config[:group]} Intance are not okay #{instance_in_service} \n"
+      else
+        result += "#{config[:group]} Intance are inService #{instance_in_service} \n"
+      end
+    end
+    if critical == 1
+      critical result
+    elsif warning == 1
+      warning result
+    else
+      ok result
+    end
+  end
+end

data/bin/check-autoscaling-cpucredits.rb

@@ -0,0 +1,160 @@
+#! /usr/bin/env ruby
+#
+# check-autoscaling-cpucredits
+#
+# DESCRIPTION:
+#   Check AutoScaling CPU Credits through CloudWatch API.
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   ./check-autoscaling-cpucredits.rb -r ${your_region} --warning-under 100 --critical-under 50
+#
+# NOTES:
+#   Based heavily on Yohei Kawahara's check-ec2-network
+#
+# LICENSE:
+#   Gavin Hamill <gavin@bashton.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'aws-sdk'
+
+class CheckEc2CpuCredits < Sensu::Plugin::Check::CLI
+  option :aws_access_key,
+         short:       '-a AWS_ACCESS_KEY',
+         long:        '--aws-access-key AWS_ACCESS_KEY',
+         description: "AWS Access Key. Either set ENV['AWS_ACCESS_KEY'] or provide it as an option",
+         default:     ENV['AWS_ACCESS_KEY']
+
+  option :aws_secret_access_key,
+         short:       '-k AWS_SECRET_KEY',
+         long:        '--aws-secret-access-key AWS_SECRET_KEY',
+         description: "AWS Secret Access Key. Either set ENV['AWS_SECRET_KEY'] or provide it as an option",
+         default:     ENV['AWS_SECRET_KEY']
+
+  option :aws_region,
+         short:       '-r AWS_REGION',
+         long:        '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default:     'us-east-1'
+
+  option :group,
+         short:       '-g G',
+         long:        '--autoscaling-group GROUP',
+         description: 'AutoScaling group to check'
+
+  option :end_time,
+         short:       '-t T',
+         long:        '--end-time TIME',
+         default:     Time.now,
+         description: 'CloudWatch metric statistics end time'
+
+  option :period,
+         short:       '-p N',
+         long:        '--period SECONDS',
+         default:     60,
+         description: 'CloudWatch metric statistics period'
+
+  option :countmetric,
+         short:       '-d M',
+         long:        '--countmetric METRIC',
+         default:     'CPUCreditBalance',
+         description: 'Select any CloudWatch _Count_ based metric (Status Checks / CPU Credits)'
+
+  option :warning_under,
+         short:       '-w N',
+         long:        '--warning-under VALUE',
+         description: 'Issue a warning if the CloudWatch _Count_ based metric (Status Check / CPU Credits) is below this value'
+
+  option :critical_under,
+         short:       '-c N',
+         long:        '--critical-under VALUE',
+         description: 'Issue a critical if the CloudWatch _Count_ based metric (Status Check / CPU Credits) is below this value'
+
+  def aws_config
+    { access_key_id: config[:aws_access_key],
+      secret_access_key: config[:aws_secret_access_key],
+      region: config[:aws_region] }
+  end
+
+  def asg
+    @asg ||= Aws::AutoScaling::Client.new aws_config
+  end
+
+  def cloud_watch
+    @cloud_watch ||= Aws::CloudWatch::Client.new aws_config
+  end
+
+  def get_count_metric(group)
+    cloud_watch.get_metric_statistics(
+      namespace: 'AWS/EC2',
+      metric_name: config[:countmetric].to_s,
+      dimensions: [
+        {
+          name: 'AutoScalingGroupName',
+          value: group
+        }
+      ],
+      start_time: config[:end_time] - 600,
+      end_time: config[:end_time],
+      statistics: ['Average'],
+      period: config[:period],
+      unit: 'Count'
+    )
+  end
+
+  def latest_value(value)
+    value.datapoints[0][:average].to_f unless value.datapoints[0].nil?
+  end
+
+  def check_metric(group)
+    metric = get_count_metric group
+    latest_value metric unless metric.nil?
+  end
+
+  def check_group(group, reportstring, warnflag, critflag)
+    metric_value = check_metric group
+    if !metric_value.nil? && metric_value < config[:critical_under].to_f
+      critflag = 1
+      reportstring = reportstring + group + ': ' + metric_value.to_s + ' '
+    elsif !metric_value.nil? && metric_value < config[:warning_under].to_f
+      warnflag = 1
+      reportstring = reportstring + group + ': ' + metric_value.to_s + ' '
+    end
+    [reportstring, warnflag, critflag]
+  end
+
+  def run
+    warnflag = 0
+    critflag = 0
+    reportstring = ''
+    if config[:group].nil?
+      asg.describe_auto_scaling_groups.auto_scaling_groups.each do |group|
+        if group.desired_capacity > 0
+          reportstring, warnflag, critflag = check_group(group.auto_scaling_group_name, reportstring, warnflag, critflag)
+        end
+      end
+    else
+      reportstring, warnflag, critflag = check_group(config[:group], reportstring, warnflag, critflag)
+    end
+
+    if critflag == 1
+      critical reportstring
+    elsif warnflag == 1
+      warning reportstring
+    else
+      ok 'All checked AutoScaling Groups are cool'
+    end
+  end
+end

data/bin/check-beanstalk-elb-metric.rb

@@ -0,0 +1,123 @@
+#! /usr/bin/env ruby
+#
+# check-beanstalk-elb-metric
+#
+# DESCRIPTION:
+#   This plugin finds the desired ELB in a beanstalk environment and queries
+#   for the requested cloudwatch metric for that ELB
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   ./check-beanstalk-elb-metric -e MyAppEnv -m Latency -c 100
+#
+# NOTES:
+#
+# LICENSE:
+#   Andrew Matheny
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-aws/cloudwatch-common'
+require 'sensu-plugin/check/cli'
+require 'aws-sdk'
+
+class BeanstalkELBCheck < Sensu::Plugin::Check::CLI
+  option :environment,
+         description: 'Application environment name',
+         short: '-e ENVIRONMENT_NAME',
+         long: '--environment ENVIRONMENT_NAME',
+         required: true
+
+  option :elb_idx,
+         description: 'Index of ELB.  Useful for multiple ELB environments',
+         short: '-i ELB_NUM',
+         long: '--elb-idx ELB_NUM',
+         default: 0,
+         proc: proc(&:to_i)
+
+  option :metric_name,
+         description: 'ELB CloudWatch Metric',
+         short: '-m METRIC_NAME',
+         long: '--metric METRIC_NAME',
+         required: true
+
+  option :period,
+         description: 'CloudWatch metric statistics period. Must be a multiple of 60',
+         short: '-p N',
+         long: '--period SECONDS',
+         default: 60,
+         proc: proc(&:to_i)
+
+  option :statistics,
+         short: '-s N',
+         long: '--statistics NAME',
+         default: 'Average',
+         description: 'CloudWatch statistics method'
+
+  option :unit,
+         short: '-u UNIT',
+         long: '--unit UNIT',
+         description: 'CloudWatch metric unit'
+
+  option :critical,
+         description: 'Trigger a critical when value is over VALUE',
+         short: '-c VALUE',
+         long: '--critical VALUE',
+         proc: proc(&:to_f),
+         required: true
+
+  option :warning,
+         description: 'Trigger a warning when value is over VALUE',
+         short: '-w VALUE',
+         long: '--warning VALUE',
+         proc: proc(&:to_f)
+
+  option :compare,
+         description: 'Comparision operator for threshold: equal, not, greater, less',
+         short: '-o OPERATION',
+         long: '--operator OPERATION',
+         default: 'greater'
+
+  option :no_data_ok,
+         short: '-n',
+         long: '--allow-no-data',
+         description: 'Returns ok if no data is returned from the metric',
+         boolean: true,
+         default: false
+
+  include CloudwatchCommon
+
+  def metric_desc
+    @metric_desc ||= "BeanstalkELB/#{config[:environment]}/#{elb_name}/#{config[:metric_name]}"
+  end
+
+  def elb_name
+    @elb_name ||= Aws::ElasticBeanstalk::Client.new
+                                               .describe_environment_resources(environment_name: config[:environment])
+                                               .environment_resources
+                                               .load_balancers[config[:elb_idx]]
+                                               .name
+  end
+
+  def run
+    new_config = config.clone
+    new_config[:namespace] = 'AWS/ELB'
+    new_config[:dimensions] = [
+      {
+        name: 'LoadBalancerName',
+        value: elb_name
+      }
+    ]
+    check new_config
+  end
+end