sensu-plugins-aws 2.1.0 → 2.1.1

data/bin/check-ec2-filter.rb

@@ -107,11 +107,11 @@ class EC2Filter < Sensu::Plugin::Check::CLI
 
     filter = Filter.parse(config[:filter])
 
-    if filter.empty?
-      options = {}
-    else
-      options = { filters: filter }
-    end
+    options = if filter.empty?
+                {}
+              else
+                { filters: filter }
+              end
 
     data = client.describe_instances(options)
 

data/bin/check-ec2-network.rb

@@ -12,7 +12,7 @@
 #   Linux
 #
 # DEPENDENCIES:
-#   gem: aws-sdk-v1
+#   gem: aws-sdk
 #   gem: sensu-plugin
 #
 # USAGE:
@@ -29,7 +29,7 @@
 #
 
 require 'sensu-plugin/check/cli'
-require 'aws-sdk-v1'
+require 'aws-sdk'
 
 class CheckEc2Network < Sensu::Plugin::Check::CLI
   option :aws_access_key,
@@ -87,34 +87,38 @@ class CheckEc2Network < Sensu::Plugin::Check::CLI
   end
 
   def ec2
-    @ec2 ||= AWS::EC2.new aws_config
+    @ec2 ||= Aws::EC2::Client.new aws_config
   end
 
   def cloud_watch
-    @cloud_watch ||= AWS::CloudWatch.new aws_config
+    @cloud_watch ||= Aws::CloudWatch::Client.new aws_config
   end
 
   def network_metric(instance)
-    cloud_watch.metrics.with_namespace('AWS/EC2').with_metric_name("#{config[:direction]}").with_dimensions(name: 'InstanceId', value: instance).first
-  end
-
-  def statistics_options
-    {
+    cloud_watch.get_metric_statistics(
+      namespace: 'AWS/EC2',
+      metric_name: config[:direction].to_s,
+      dimensions: [
+        {
+          name: 'InstanceId',
+          value: instance
+        }
+      ],
       start_time: config[:end_time] - 300,
-      end_time:   config[:end_time],
+      end_time: config[:end_time],
       statistics: ['Average'],
-      period:     config[:period]
-    }
+      period: config[:period],
+      unit: 'Bytes'
+    )
   end
 
-  def latest_value(metric)
-    value = metric.statistics(statistics_options.merge unit: 'Bytes')
+  def latest_value(value)
     value.datapoints[0][:average].to_f unless value.datapoints[0].nil?
   end
 
   def check_metric(instance)
     metric = network_metric instance
-    latest_value metric
+    latest_value metric unless metric.nil?
   end
 
   def run

data/bin/check-elb-certs.rb

@@ -128,11 +128,11 @@ class CheckELBCerts < Sensu::Plugin::Check::CLI
       unknown "An error occurred processing AWS ELB API: #{e.message}"
     end
 
-    if critical_message.length > 0
+    if !critical_message.length.empty?
       message = cert_message(critical_message.length, 'expiring within', config[:crit_under])
       message += ': ' + critical_message.sort.join(' ')
       critical message
-    elsif warning_message.length > 0
+    elsif !warning_message.empty?
       message = cert_message(warning_message.length, 'expiring within', config[:warn_under])
       message += ': ' + warning_message.sort.join(' ')
       warning message

data/bin/check-elb-health-fog.rb

@@ -103,12 +103,10 @@ class ELBHealth < Sensu::Plugin::Check::CLI
       end
       if unhealthy_instances.empty?
         ok "All instances on ELB #{aws_region}::#{config[:elb_name]} healthy!"
+      elsif config[:verbose]
+        critical "Unhealthy instances detected: #{unhealthy_instances.map { |id, state| '[' + id + '::' + state + ']' }.join(' ')}"
       else
-        if config[:verbose]
-          critical "Unhealthy instances detected: #{unhealthy_instances.map { |id, state| '[' + id + '::' + state + ']' }.join(' ')}"
-        else
-          critical "Detected [#{unhealthy_instances.size}] unhealthy instances"
-        end
+        critical "Detected [#{unhealthy_instances.size}] unhealthy instances"
       end
     rescue => e
       warning "An issue occured while communicating with the AWS EC2 API: #{e.message}"

data/bin/check-elb-health-sdk.rb

@@ -92,11 +92,11 @@ class ELBHealth < Sensu::Plugin::Check::CLI
 
   def check_health(elb)
     unhealthy_instances = {}
-    if config[:instances]
-      instance_health_hash = elb.instances.health(config[:instances])
-    else
-      instance_health_hash = elb.instances.health
-    end
+    instance_health_hash = if config[:instances]
+                             elb.instances.health(config[:instances])
+                           else
+                             elb.instances.health
+                           end
     instance_health_hash.each do |instance_health|
       if instance_health[:state] != 'InService'
         unhealthy_instances[instance_health[:instance].id] = instance_health[:state]

data/bin/check-elb-latency.rb

@@ -123,7 +123,7 @@ class CheckELBLatency < Sensu::Plugin::Check::CLI
   end
 
   def latest_value(metric)
-    metric.statistics(statistics_options.merge unit: 'Seconds').datapoints.sort_by { |datapoint| datapoint[:timestamp] }.last[config[:statistics]]
+    metric.statistics(statistics_options.merge(unit: 'Seconds')).datapoints.sort_by { |datapoint| datapoint[:timestamp] }.last[config[:statistics]]
   end
 
   def flag_alert(severity, message)

data/bin/check-elb-sum-requests.rb

@@ -115,7 +115,7 @@ class CheckELBSumRequests < Sensu::Plugin::Check::CLI
   end
 
   def latest_value(metric)
-    metric.statistics(statistics_options.merge unit: 'Count').datapoints.sort_by { |datapoint| datapoint[:timestamp] }.last[:sum]
+    metric.statistics(statistics_options.merge(unit: 'Count')).datapoints.sort_by { |datapoint| datapoint[:timestamp] }.last[:sum]
   end
 
   def flag_alert(severity, message)

data/bin/check-emr-cluster.rb

@@ -106,10 +106,8 @@ class CheckEMRCluster < Sensu::Plugin::Check::CLI
   def run
     aws_config = {}
     if config[:use_iam_role].nil?
-      aws_config.merge!(
-        access_key_id: config[:aws_access_key],
-        secret_access_key: config[:aws_secret_access_key]
-      )
+      aws_config[:access_key_id] = config[:aws_access_key]
+      aws_config[:secret_access_key] = config[:aws_secret_access_key]
     end
 
     emr = Aws::EMR::Client.new(aws_config.merge!(region: config[:aws_region]))
@@ -118,7 +116,7 @@ class CheckEMRCluster < Sensu::Plugin::Check::CLI
       clusters = emr_clusters.select { |c| c.name == config[:cluster_name] }
 
       critical "EMR cluster #{config[:cluster_name]} appears #{clusters.size} times" if clusters.size > 1
-      critical "EMR cluster #{config[:cluster_name]} not found" if clusters.size == 0
+      critical "EMR cluster #{config[:cluster_name]} not found" if clusters.empty?
 
       cluster = clusters.first
       state = cluster.status.state

data/bin/check-instance-events.rb

@@ -72,10 +72,8 @@ class CheckInstanceEvents < Sensu::Plugin::Check::CLI
     aws_config = {}
 
     if config[:use_iam_role].nil?
-      aws_config.merge!(
-        access_key_id: config[:aws_access_key],
-        secret_access_key: config[:aws_secret_access_key]
-      )
+      aws_config[:access_key_id] = config[:aws_access_key]
+      aws_config[:secret_access_key] = config[:aws_secret_access_key]
     end
 
     ec2 = AWS::EC2::Client.new(aws_config.merge!(region: config[:aws_region]))

data/bin/check-instance-health.rb

@@ -0,0 +1,80 @@
+#! /usr/bin/env ruby
+#
+# check-instance-health
+#
+# DESCRIPTION:
+#   This plugin looks up all instances in an account and checks event data, system status
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   Shane Starcher
+#   Copyright (c) 2016
+#   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 CheckInstanceEvents < 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: 'us-east-1'
+
+  def gather_events(events)
+    useful_events = events.reject { |x| x[:code] == 'system-reboot' && x[:description] =~ /\[Completed\]/ }
+    !useful_events.empty?
+  end
+
+  def gather_status(status_checks)
+    ['impaired', 'insufficient-data'].include? status_checks.status
+  end
+
+  def run
+    messages = []
+    ec2 = Aws::EC2::Client.new
+    begin
+      ec2.describe_instance_status.instance_statuses.each do |item|
+        id = item.instance_id
+        if gather_events(item.events)
+          messages << "#{id} has unscheduled events"
+        end
+
+        if gather_status(item.system_status)
+          messages << "#{id} has failed system status checks"
+        end
+
+        if gather_status(item.instance_status)
+          messages << "#{id} has failed instance status checks"
+        end
+      end
+    rescue => e
+      unknown "An error occurred processing AWS EC2 API: #{e.message}"
+    end
+
+    if messages.count > 0
+      critical("#{messages.count} instances #{messages.count > 1 ? 'have' : 'has'}: #{messages.join(',')}")
+    else
+      ok
+    end
+  end
+end

data/bin/check-rds-events.rb

@@ -5,9 +5,12 @@
 #
 # DESCRIPTION:
 #   This plugin checks rds clusters for critical events.
-#   Due to the number of events types on RDS clusters the check searches for
-#   events containing the text string 'has started' or 'is being'.  These events all have
-#   accompanying completiion events and are impacting events
+#   Due to the number of events types on RDS clusters, the check
+#   should filter out non-disruptive events that are part of
+#   basic operations.
+#
+#   More info on RDS events:
+#   http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_Events.html
 #
 # OUTPUT:
 #   plain-text
@@ -76,14 +79,22 @@ class CheckRDSEvents < Sensu::Plugin::Check::CLI
       clusters = rds.describe_db_instances[:db_instances].map { |db| db[:db_instance_identifier] }
       maint_clusters = []
 
-      # fetch the last 2 hours of events for each cluster
+      # fetch the last 15 minutes of events for each cluster
+      # that way, we're only spammed with persistent notifications that we'd care about.
       clusters.each do |cluster_name|
-        events_record = rds.describe_events(start_time: (Time.now - 7200).iso8601, source_type: 'db-instance', source_identifier: cluster_name)
+        events_record = rds.describe_events(start_time: (Time.now - 900).iso8601, source_type: 'db-instance', source_identifier: cluster_name)
         next if events_record[:events].empty?
 
-        # if the last event is a start maint event then the cluster is still in maint
+        # we will need to filter out non-disruptive/basic operation events.
+        # ie. the regular backup operations
+        next if events_record[:events][-1][:message] =~ /Backing up DB instance|Finished DB Instance backup|Restored from snapshot/
+        # ie. Replication resumed
+        next if events_record[:events][-1][:message] =~ /Replication for the Read Replica resumed/
+        # you can add more filters to skip more events.
+
+        # draft the messages
         cluster_name_long = "#{cluster_name} (#{aws_config[:region]}) #{events_record[:events][-1][:message]}"
-        maint_clusters.push(cluster_name_long) if events_record[:events][-1][:message] =~ /has started|is being|off-line|shutdown/
+        maint_clusters.push(cluster_name_long)
       end
     rescue => e
       unknown "An error occurred processing AWS RDS API: #{e.message}"

data/bin/check-rds.rb

@@ -12,7 +12,7 @@
 #   Linux
 #
 # DEPENDENCIES:
-#   gem: aws-sdk-v1
+#   gem: aws-sdk
 #   gem: sensu-plugin
 #
 # USAGE:
@@ -51,7 +51,7 @@
 #
 
 require 'sensu-plugin/check/cli'
-require 'aws-sdk-v1'
+require 'aws-sdk'
 require 'time'
 
 class CheckRDS < Sensu::Plugin::Check::CLI
@@ -126,36 +126,39 @@ class CheckRDS < Sensu::Plugin::Check::CLI
   end
 
   def rds
-    @rds ||= AWS::RDS.new aws_config
+    @rds ||= Aws::RDS::Client.new aws_config
   end
 
   def cloud_watch
-    @cloud_watch ||= AWS::CloudWatch.new aws_config
+    @cloud_watch ||= Aws::CloudWatch::Client.new aws_config
   end
 
   def find_db_instance(id)
-    db = rds.instances[id]
-    fail unless db.exists?
+    db = rds.describe_db_instances.db_instances.select { |db_instance| db_instance.db_instance_identifier == id }
+    unknown 'DB instance not found.' if db.empty?
     db
-  rescue
-    unknown 'DB instance not found.'
   end
 
-  def cloud_watch_metric(metric_name)
-    cloud_watch.metrics.with_namespace('AWS/RDS').with_metric_name(metric_name).with_dimensions(name: 'DBInstanceIdentifier', value: @db_instance.id).first
-  end
-
-  def statistics_options
-    {
+  def cloud_watch_metric(metric_name, unit)
+    cloud_watch.get_metric_statistics(
+      namespace: 'AWS/RDS',
+      metric_name: metric_name,
+      dimensions: [
+        {
+          name: 'DBInstanceIdentifier',
+          value: @db_instance.id
+        }
+      ],
       start_time: config[:end_time] - config[:period],
-      end_time:   config[:end_time],
+      end_time: config[:end_time],
       statistics: [config[:statistics].to_s.capitalize],
-      period:     config[:period]
-    }
+      period: config[:period],
+      unit: unit
+    )
   end
 
-  def latest_value(metric, unit)
-    values = metric.statistics(statistics_options.merge unit: unit).datapoints.sort_by { |datapoint| datapoint[:timestamp] }
+  def latest_value(metric)
+    values = metric.datapoints.sort_by { |datapoint| datapoint[:timestamp] }
 
     # handle time periods that are too small to return usable values.  # this is a cozy addition that wouldn't port upstream.
     if values.empty?
@@ -205,20 +208,20 @@ class CheckRDS < Sensu::Plugin::Check::CLI
   end
 
   def check_az(severity, expected_az)
-    return if @db_instance.availability_zone_name == expected_az
-    flag_alert severity, "; AZ is #{@db_instance.availability_zone_name} (expected #{expected_az})"
+    return if @db_instance.availability_zone == expected_az
+    flag_alert severity, "; AZ is #{@db_instance.availability_zone} (expected #{expected_az})"
   end
 
   def check_cpu(severity, expected_lower_than)
-    @cpu_metric ||= cloud_watch_metric 'CPUUtilization'
-    @cpu_metric_value ||= latest_value @cpu_metric, 'Percent'
+    @cpu_metric ||= cloud_watch_metric 'CPUUtilization', 'Percent'
+    @cpu_metric_value ||= latest_value @cpu_metric
     return if @cpu_metric_value < expected_lower_than
     flag_alert severity, "; CPUUtilization is #{sprintf '%.2f', @cpu_metric_value}% (expected lower than #{expected_lower_than}%)"
   end
 
   def check_memory(severity, expected_lower_than)
-    @memory_metric ||= cloud_watch_metric 'FreeableMemory'
-    @memory_metric_value ||= latest_value @memory_metric, 'Bytes'
+    @memory_metric ||= cloud_watch_metric 'FreeableMemory', 'Bytes'
+    @memory_metric_value ||= latest_value @memory_metric
     @memory_total_bytes ||= memory_total_bytes @db_instance.db_instance_class
     @memory_usage_bytes ||= @memory_total_bytes - @memory_metric_value
     @memory_usage_percentage ||= @memory_usage_bytes / @memory_total_bytes * 100
@@ -227,8 +230,8 @@ class CheckRDS < Sensu::Plugin::Check::CLI
   end
 
   def check_disk(severity, expected_lower_than)
-    @disk_metric ||= cloud_watch_metric 'FreeStorageSpace'
-    @disk_metric_value ||= latest_value @disk_metric, 'Bytes'
+    @disk_metric ||= cloud_watch_metric 'FreeStorageSpace', 'Bytes'
+    @disk_metric_value ||= latest_value @disk_metric
     @disk_total_bytes ||= @db_instance.allocated_storage * 1024**3
     @disk_usage_bytes ||= @disk_total_bytes - @disk_metric_value
     @disk_usage_percentage ||= @disk_usage_bytes / @disk_total_bytes * 100

data/bin/check-s3-bucket.rb

@@ -70,10 +70,8 @@ class CheckS3Bucket < Sensu::Plugin::Check::CLI
     aws_config = {}
 
     if config[:use_iam_role].nil?
-      aws_config.merge!(
-        access_key_id: config[:aws_access_key],
-        secret_access_key: config[:aws_secret_access_key]
-      )
+      aws_config[:access_key_id] = config[:aws_access_key]
+      aws_config[:secret_access_key] = config[:aws_secret_access_key]
     end
 
     s3 = Aws::S3::Client.new(aws_config.merge!(region: config[:aws_region]))

data/bin/check-s3-object.rb

@@ -101,10 +101,8 @@ class CheckS3Bucket < Sensu::Plugin::Check::CLI
   def run
     aws_config = {}
     if config[:use_iam_role].nil?
-      aws_config.merge!(
-        access_key_id: config[:aws_access_key],
-        secret_access_key: config[:aws_secret_access_key]
-      )
+      aws_config[:access_key_id] = config[:aws_access_key]
+      aws_config[:secret_access_key] = config[:aws_secret_access_key]
     end
 
     s3 = Aws::S3::Client.new(aws_config.merge!(region: config[:aws_region]))