sensu-plugins-aws 3.2.1 → 4.0.0

data/bin/check-cloudwatch-metric.rb

@@ -27,11 +27,17 @@
 #   for details.
 #
 
-require 'sensu-plugins-aws/cloudwatch-common'
+require 'sensu-plugins-aws'
 require 'sensu-plugin/check/cli'
 require 'aws-sdk'
 
 class CloudWatchMetricCheck < Sensu::Plugin::Check::CLI
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default: 'us-east-1'
+
   option :namespace,
          description: 'CloudWatch namespace for metric',
          short: '-n NAME',

data/bin/check-ebs-burst-limit.rb

@@ -0,0 +1,96 @@
+#! /usr/bin/env ruby
+#
+# check-ebs-burst-limit
+#
+# DESCRIPTION:
+#   Check EC2 Attached Volumes for volumes with low burst balance
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   ./check-ebs-burst-limit.rb -r ${you_region}
+#   ./check-ebs-burst-limit.rb -r ${you_region} -c 50
+#   ./check-ebs-burst-limit.rb -r ${you_region} -w 50 -c 10
+#
+# LICENSE:
+#   Barry Martin <nyxcharon@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'sensu-plugins-aws'
+require 'aws-sdk'
+
+class CheckEbsBurstLimit < Sensu::Plugin::Check::CLI
+  include CloudwatchCommon
+
+  option :aws_region,
+         short:       '-r R',
+         long:        '--region REGION',
+         description: 'AWS region',
+         default: 'us-east-1'
+
+  option :critical,
+         description: 'Trigger a critical when ebs purst limit is under VALUE',
+         short: '-c VALUE',
+         long: '--critical VALUE',
+         proc: proc(&:to_f),
+         required: true
+
+  option :warning,
+         description: 'Trigger a warning when ebs purst limit is under VALUE',
+         short: '-w VALUE',
+         long: '--warning VALUE',
+         proc: proc(&:to_f)
+
+  def run
+    errors = []
+    ec2 = Aws::EC2::Client.new
+    volumes = ec2.describe_volumes(
+      filters: [
+        {
+          name: 'attachment.status',
+          values: ['attached']
+        }
+      ]
+    )
+    config[:metric_name] = 'BurstBalance'
+    config[:namespace] = 'AWS/EBS'
+    config[:statistics] = 'Average'
+    config[:period] = 60
+    crit = false
+    should_warn = false
+
+    volumes[:volumes].each do |volume|
+      config[:dimensions] = []
+      config[:dimensions] << { name: 'VolumeId', value: volume[:volume_id] }
+      resp = client.get_metric_statistics(metrics_request(config))
+      unless resp.datapoints.first.nil?
+        if resp.datapoints.first[:average] < config[:critical]
+          errors << "#{volume[:volume_id]} #{resp.datapoints.first[:average]}"
+          crit = true
+        elsif resp.datapoints.first[:average] < config[:warning]
+          errors << "#{volume[:volume_id]} #{resp.datapoints.first[:average]}"
+          should_warn = true
+        end
+      end
+    end
+
+    if crit
+      critical "Volume(s) have exceeded critical threshold: #{errors}"
+    elsif should_warn
+      warning "Volume(s) have exceeded warning threshold: #{errors}"
+    else
+      ok 'No volume(s) exceed thresholds'
+    end
+  end
+end

data/bin/check-ec2-cpu_balance.rb

@@ -93,10 +93,10 @@ class EC2CpuBalance < Sensu::Plugin::Check::CLI
         unless result.nil?
           if result < config[:critical]
             level = 2
-            messages << "#{id} is below critical threshold [#{config[:critical]} < #{result}]\n"
+            messages << "#{id} is below critical threshold [#{result} < #{config[:critical]}]\n"
           elsif config[:warning] && result < config[:warning]
             level = 1 if level == 0
-            messages << "#{id} is below warning threshold [#{config[:warning]} < #{result}]\n"
+            messages << "#{id} is below warning threshold [#{result} < #{config[:warning]}]\n"
           end
         end
       end

data/bin/check-ec2-filter.rb

@@ -75,12 +75,24 @@ class EC2Filter < Sensu::Plugin::Check::CLI
          short: '-c COUNT',
          long: '--critical COUNT'
 
+  option :exclude_tags,
+         short: '-e {<tag-key>:[VAL1, VAL2]} {<tag-key>:[VAL1, VAL2] }',
+         long: '--exclude_tags {<tag-key>:[VAL1, VAL2] } {<tag-key>:[VAL1, VAL2] }',
+         description: 'Tag Values to exclude by. Values treated as regex. Any matching value will result in exclusion.',
+         default: '{}'
+
   option :compare,
          description: 'Comparision operator for threshold: equal, not, greater, less',
          short: '-o OPERATION',
          long: '--operator OPERATION',
          default: 'equal'
 
+  option :detailed_message,
+         short: '-d',
+         long: '--detailed-message',
+         boolean: true,
+         default: false
+
   def aws_config
     { access_key_id: config[:aws_access_key],
       secret_access_key: config[:aws_secret_access_key],
@@ -102,6 +114,16 @@ class EC2Filter < Sensu::Plugin::Check::CLI
   end
 
   def run
+    filter_list = config[:exclude_tags].split(/}\s?{/).map do |x|
+      x.gsub(/[{}]/, '')
+    end
+    filter_list = filter_list.map do |y|
+      _, h2, h3 = y.split(/(.*):(.*)/)
+      { h2 => h3 }
+    end.reduce(:merge)
+    filter_list.delete(nil)
+    filter_list.each { |x, y| filter_list[x] = y.strip.gsub(/[\[\]]/, '') }
+
     client = Aws::EC2::Client.new aws_config
 
     filter = Filter.parse(config[:filter])
@@ -114,17 +136,28 @@ class EC2Filter < Sensu::Plugin::Check::CLI
 
     data = client.describe_instances(options)
 
-    instance_ids = Set.new
+    aws_instances = Set.new
+    data.reservations.each do |r|
+      r.instances.each do |i|
+        aws_instances << {
+          id: i[:instance_id],
+          tags: i.tags
+        }
+      end
+    end
 
-    data[:reservations].each do |res|
-      res[:instances].each do |i|
-        instance_ids << i[:instance_id]
+    aws_instances.delete_if do |instance|
+      instance[:tags].any? do |key|
+        filter_list.keys.include?(key.key) && filter_list[key.key].split(',').any? do |v|
+          key.value.match(/#{v.strip}/)
+        end
       end
     end
 
-    count = instance_ids.count
+    count = aws_instances.count
     op = convert_operator
     message = "Current count: #{count}"
+    message += " - #{aws_instances.collect { |x| x[:id] }.join(',')}" if config[:detailed_message] && count > 0
 
     unless config[:critical].nil?
       if op.call count, config[:critical].to_i

data/bin/check-ecs-service-health.rb

@@ -61,6 +61,12 @@ class CheckEcsServiceHealth < Sensu::Plugin::Check::CLI
          long: '--warn_as_crit',
          description: 'Consider it critical when any desired tasks are not running. Otherwise, only 0 is critical.'
 
+  option :primary_status,
+         short: '-p',
+         long: '--primary_status',
+         description: 'Checking for deployments which only have a Primary Status.',
+         default: false
+
   def ecs_client
     @ecs_client ||= Aws::ECS::Client.new
   end
@@ -95,22 +101,47 @@ class CheckEcsServiceHealth < Sensu::Plugin::Check::CLI
   end
 
   # Unhealthy if service has fewer running tasks than desired
-  def services_by_health(cluster = 'default', services = nil)
-    service_details(cluster, services).group_by { |s| bucket_service(s[:running_count], s[:desired_count]) }
+  def services_by_health(cluster = 'default', services = nil, primary_status = false)
+    bucket = nil
+    service_details(cluster, services).group_by do |service|
+      if primary_status
+        service.deployments.each do |x|
+          if x[:status].include? 'PRIMARY'
+            bucket = bucket_service(x[:running_count], x[:desired_count])
+          end
+        end
+      else
+        bucket = bucket_service(service[:running_count], service[:desired_count])
+      end
+      bucket
+    end
   end
 
   def run
-    service_healths = services_by_health(config[:cluster_name], config[:services])
+    service_healths = services_by_health(config[:cluster_name], config[:services], config[:primary_status])
 
     unhealthy = []
     unhealthy.concat(service_healths[:critical]) if service_healths.key? :critical
     unhealthy.concat(service_healths[:warn]) if service_healths.key? :warn
-    unhealthy = unhealthy.collect { |s| "#{s.service_name} (#{s.running_count}/#{s.desired_count})" }
+
+    if config[:primary_status]
+      unhealthy_p = nil
+      unhealthy = unhealthy.collect do |s|
+        s.deployments.each do |x|
+          if x[:status].include? 'PRIMARY'
+            unhealthy_p = "#{s.service_name} (#{x.running_count}/#{x.desired_count})"
+          end
+        end
+        unhealthy_p
+      end
+    else
+      unhealthy = unhealthy.collect { |s| "#{s.service_name} (#{s.running_count}/#{s.desired_count})" }
+    end
 
     if service_healths.key?(:critical) || (config[:warn_as_crit] && service_healths.key?(:warn))
-      critical("Unhealthy ECS Services: #{unhealthy.join ', '}")
+      critical("Unhealthy ECS Services(Primary only = #{config[:primary_status]}):  #{unhealthy.join ', '}")
     elsif service_healths.key?(:warn)
-      warning("Unhealthy ECS Services: #{unhealthy.join ', '}")
+      warning("Unhealthy ECS Services(Primary only = #{config[:primary_status]}): #{unhealthy.join ', '}")
     else
       ok
     end

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

@@ -0,0 +1,103 @@
+#! /usr/bin/env ruby
+#
+# check-elb-instance-inservice
+#
+# DESCRIPTION:
+#   Check Elastic Loudbalancer Instances are inService.
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   all LoadBalancers
+#   ./check-elb-instance-inservice -r ${your_region}
+#   one loadBalancer
+#   ./check-elb-instance-inservice -r ${your_region} -l 'LoadBalancerName'
+#
+# NOTES:
+#   Based heavily on Peter Hoppe check-autoscaling-instances-inservices
+#
+# 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 CheckElbInstanceInService < 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 :load_balancer,
+         short:       '-l L',
+         long:        '--load_balancer LoudBalancer',
+         description: 'LoadBalancer Name to check'
+
+  def elb
+    @elb ||= Aws::ElasticLoadBalancing::Client.new
+  end
+
+  def describe_elb(elb_name)
+    elb.describe_instance_health(
+      load_balancer_name: elb_name.to_s
+    )
+  end
+
+  def run
+    warning = 0
+    critical = 0
+    result = ''
+    if config[:load_balancer].nil?
+      elb.describe_load_balancers.load_balancer_descriptions.each do |load_balancer|
+        describe_elb(load_balancer.load_balancer_name).each do |instances|
+          instances.instance_states.each do |instance|
+            if instance.state == 'InService'
+              result += "#{instance.instance_id} state InService "
+            else
+              result += "#{instance.instance_id} state not InService "
+              warning += 1
+            end
+          end
+          if warning == instances.instance_states.length
+            critical = 1
+          end
+        end
+      end
+    else
+      describe_elb(config[:load_balancer]).each do |instances|
+        instances.instance_states.each do |instance|
+          if instance.state == 'InService'
+            result += "#{instance.instance_id} state InService "
+          else
+            result += "#{instance.instance_id} state not InService "
+            warning += 1
+          end
+        end
+        if warning == instances.instance_states.length
+          critical = 1
+        end
+      end
+    end
+    if critical == 1
+      critical result
+    elsif warning >= 1
+      warning result
+    else
+      ok result
+    end
+  end
+end

data/bin/check-instance-events.rb

@@ -28,7 +28,7 @@
 #
 
 require 'sensu-plugin/check/cli'
-require 'aws-sdk-v1'
+require 'aws-sdk'
 
 class CheckInstanceEvents < Sensu::Plugin::Check::CLI
   option :aws_access_key,
@@ -74,10 +74,7 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
   end
 
   def ec2_regions
-    # This is for SDK v2
-    # Aws.partition('aws').regions.map(&:name)
-
-    AWS::EC2.regions.map(&:name)
+    Aws.partition('aws').regions.map(&:name)
   end
 
   def run
@@ -100,15 +97,15 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
     end
 
     aws_regions.each do |r| # Iterate each possible region
-      ec2 = AWS::EC2::Client.new(aws_config.merge!(region: r))
+      ec2 = Aws::EC2::Client.new(aws_config.merge!(region: r))
       begin
         describe_instance_options = {}
         if config[:instance_id].any?
           describe_instance_options = describe_instance_options.merge(instance_ids: config[:instance_id])
         end
 
-        ec2.describe_instance_status(describe_instance_options)[:instance_status_set].each do |i|
-          next if i[:events_set].empty?
+        ec2.describe_instance_status(describe_instance_options).instance_statuses.each do |i|
+          next if i[:events].empty?
 
           # Exclude completed reboots since the events API appearently returns these even after they have been completed:
           # Example:
@@ -121,7 +118,7 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
           #     }
           # ]
           useful_events =
-            i[:events_set].reject { |x| (x[:code] =~ /system-reboot|instance-stop|system-maintenance/) && (x[:description] =~ /\[Completed\]|\[Canceled\]/) }
+            i[:events].reject { |x| (x[:code] =~ /system-reboot|instance-reboot|instance-stop|system-maintenance/) && (x[:description] =~ /\[Completed\]|\[Canceled\]/) }
 
           unless useful_events.empty?
             if config[:include_name]
@@ -132,9 +129,9 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
               rescue => e
                 puts "Issue getting instance details for #{i[:instance_id]} (#{r}).  Exception = #{e}"
               end
-              event_instances << "#{name} (#{i[:instance_id]} #{r}) (#{i[:events_set][0][:code]}) #{i[:events_set][0][:description]}"
+              event_instances << "#{name} (#{i[:instance_id]} #{r}) (#{i[:events][0][:code]}) #{i[:events][0][:description]}"
             else
-              event_instances << "#{i[:instance_id]} (#{r}) (#{i[:events_set][0][:code]}) #{i[:events_set][0][:description]}"
+              event_instances << "#{i[:instance_id]} (#{r}) (#{i[:events][0][:code]}) #{i[:events][0][:description]}"
             end
           end
         end

data/bin/check-instance-health.rb

@@ -39,6 +39,11 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
          long: '--aws-region REGION',
          description: 'AWS Region (defaults to us-east-1).',
          default: 'us-east-1'
+  option :filter,
+         short: '-f FILTER',
+         long: '--filter FILTER',
+         description: 'String representation of the filter to apply',
+         default: '{}'
 
   def gather_events(events)
     useful_events = events.reject { |x| (x[:code] =~ /system-reboot|instance-stop|system-maintenance/) && (x[:description] =~ /\[Completed\]|\[Canceled\]/) }
@@ -50,10 +55,28 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
   end
 
   def run
+    filter = Filter.parse(config[:filter])
+    options = if filter.empty?
+                {}
+              else
+                { filters: filter }
+              end
+
     messages = []
+
     ec2 = Aws::EC2::Client.new
+    instance_ids = []
+
+    instances = ec2.describe_instances(options)
+    instances.reservations.each do |r|
+      r.instances.each do |i|
+        instance_ids.push(i[:instance_id])
+      end
+    end
+
     begin
-      ec2.describe_instance_status.instance_statuses.each do |item|
+      resp = ec2.describe_instance_status(instance_ids: instance_ids)
+      resp.instance_statuses.each do |item|
         id = item.instance_id
         if gather_events(item.events)
           messages << "#{id} has unscheduled events"