sensu-plugins-aws 3.2.1 → 4.0.0

data/bin/check-s3-tag.rb

@@ -0,0 +1,70 @@
+#! /usr/bin/env ruby
+#
+# check-s3-tag
+#
+# DESCRIPTION:
+#   This plugin checks if buckets have a set of tags.
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   ./check-s3-tag.rb --aws-region eu-west-1 --tag-keys xxx
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright (c) 2016, Olivier Bazoud, olivier.bazoud@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/common'
+require 'aws-sdk'
+
+class CheckS3Tag < 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'
+
+  option :tag_keys,
+         short: '-t TAG_KEYS',
+         long: '--tag-keys TAG_KEYS',
+         description: 'Tag keys'
+
+  def run
+    tags = config[:tag_keys].split(',')
+    s3 = Aws::S3::Client.new
+    missing_tags = []
+    s3.list_buckets.buckets.each do |bucket|
+      begin
+        keys = s3.get_bucket_tagging(bucket: bucket.name).tag_set.map(&:key)
+        if keys.sort & tags.sort != tags.sort
+          missing_tags.push bucket.name
+        end
+      rescue => _
+        missing_tags.push bucket.name
+      end
+    end
+
+    if missing_tags.empty?
+      ok
+    else
+      critical("Missing tags in #{missing_tags}")
+    end
+  rescue => e
+    critical "Error: #{e.message} - #{e.backtrace}"
+  end
+end

data/bin/check-ses-limit.rb

@@ -75,7 +75,7 @@ class CheckSESLimit < Sensu::Plugin::Check::CLI
 
     unknown 'Empty response from AWS SES API' if response.empty? # Can this happen?
 
-    percent = (response.sent_last_24_hours.to_i / response.max_24_hour_send.to_i) * 100
+    percent = ((response.sent_last_24_hours.to_f / response.max_24_hour_send.to_f) * 100).to_i
     message = "SES sending limit is at #{percent}%"
 
     if config[:crit_percent] > 0 && config[:crit_percent] <= percent

data/bin/check-sqs-messages.rb

@@ -28,23 +28,14 @@
 #
 
 require 'sensu-plugin/check/cli'
-require 'aws-sdk-v1'
+require 'sensu-plugins-aws'
+require 'aws-sdk'
 
 #
 # Check SQS Messages
 #
 class SQSMsgs < 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']
+  include Common
 
   option :aws_region,
          short: '-r AWS_REGION',
@@ -64,6 +55,12 @@ class SQSMsgs < Sensu::Plugin::Check::CLI
          description: 'The prefix of the queues you want to check the number of messages for',
          default: ''
 
+  option :metric,
+         short: '-m METTIC',
+         long: '--metric METRIC',
+         description: 'The metric of the queues you want to check the number of messages for',
+         default: 'ApproximateNumberOfMessages'
+
   option :warn_over,
          short: '-w WARN_OVER',
          long: '--warnnum WARN_OVER',
@@ -99,15 +96,16 @@ class SQSMsgs < Sensu::Plugin::Check::CLI
   end
 
   def run
-    AWS.config aws_config
-    sqs = AWS::SQS.new
+    Aws.config.update(aws_config)
+    sqs = Aws::SQS::Resource.new
 
     if config[:prefix] == ''
       if config[:queue] == ''
         critical 'Error, either QUEUE or PREFIX must be specified'
       end
 
-      messages = sqs.queues.named(config[:queue]).approximate_number_of_messages
+      url = sqs.get_queue_by_name(queue_name: config[:queue]).url
+      messages = sqs.client.get_queue_attributes(queue_url: url, attribute_names: ['All']).attributes[config[:metric]].to_i
 
       if (config[:crit_under] >= 0 && messages < config[:crit_under]) || (config[:crit_over] >= 0 && messages > config[:crit_over])
         critical "#{messages} message(s) in #{config[:queue]} queue"
@@ -121,9 +119,9 @@ class SQSMsgs < Sensu::Plugin::Check::CLI
       crit = false
       queues = []
 
-      sqs.queues.with_prefix(config[:prefix]).each do |q|
-        queue_name = q.arn.split(':').last
-        messages = q.approximate_number_of_messages
+      sqs.queues(queue_name_prefix: config[:prefix]).each do |q|
+        messages = sqs.client.get_queue_attributes(queue_url: q.url, attribute_names: ['All']).attributes[config[:metric]].to_i
+        queue_name = q.attributes['QueueArn'].split(':').last
 
         if (config[:crit_under] >= 0 && messages < config[:crit_under]) || (config[:crit_over] >= 0 && messages > config[:crit_over])
           crit = true

data/bin/check-vpc-vpn.rb

@@ -13,7 +13,8 @@
 #
 # DEPENDENCIES:
 #   gem: sensu-plugin
-#   gem: aws-sdk-v1
+#   gem: aws-sdk
+#   gem: sensu-plugins-aws
 #
 # USAGE:
 #  ./check-vpc-vpn.rb --aws-region us-east-1 --vpn-connection-id vpn-abc1234
@@ -25,61 +26,50 @@
 #   John Dyer johntdyer@gmail.com
 #   Released under the same terms as Sensu (the MIT license); see LICENSE
 #   for details.
+#   Updated by Peter Hoppe <peter.hoppe.extern@bertelsmann.de> to aws-sdk-v2
 #
 
+require 'sensu-plugins-aws'
 require 'sensu-plugin/check/cli'
-require 'aws-sdk-v1'
+require 'aws-sdk'
 
 class CheckAwsVpcVpnConnections < Sensu::Plugin::Check::CLI
-  @aws_config = {}
-  # rubocop:disable Style/AlignParameters
-  option :access_key,
-    short: '-a AWS_ACCESS_KEY',
-    long: '--aws-access-key AWS_ACCESS_KEY',
-    description: 'AWS Access Key',
-    default: ENV['AWS_ACCESS_KEY_ID']
-
-  option :secret_key,
-    short: '-s AWS_SECRET_ACCESS_KEY',
-    long: '--aws-secret-access-key AWS_SECRET_ACCESS_KEY',
-    description: 'AWS Secret Access Key.',
-    default: ENV['AWS_SECRET_ACCESS_KEY']
-
-  option :use_iam_role,
-    short: '-u',
-    long: '--use-iam',
-    description: 'Use IAM authentication'
-
+  include Common
   option :vpn_id,
-    short: '-v VPN_ID',
-    long: '--vpn-connection-id VPN_ID',
-    required: true,
-    description: 'VPN connection ID'
+         short: '-v VPN_ID',
+         long: '--vpn-connection-id VPN_ID',
+         required: true,
+         description: 'VPN connection ID'
 
   option :aws_region,
-    short: '-r AWS_REGION',
-    long: '--aws-region REGION',
-    description: 'AWS Region (such as eu-west-1).',
-    default: 'us-east-1'
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default: ENV['AWS_REGION']
 
-  def aws_config
-    aws_connection_config = { region: config[:aws_region] }
-    if config[:use_iam_role].nil?
-      aws_connection_config[:access_key_id] = config[:access_key]
-      aws_connection_config[:secret_access_key] = config[:secret_key]
-    end
-    aws_connection_config
-  end
+  option :warn_count,
+         short: '-W WARN_COUNT',
+         long: '--warn_count WARN_COUNT',
+         description: 'Warn when the count of down tunnels is at or above this number',
+         default: 1,
+         proc: proc(&:to_i)
+
+  option :crit_count,
+         short: '-C CRIT_COUNT',
+         long: '--crit_count CRIT_COUNT',
+         description: 'Critical when the count of down tunnels is at or above this number',
+         default: 2,
+         proc: proc(&:to_i)
 
   def fetch_connection_data
     begin
-      ec2 = AWS::EC2::Client.new(aws_config)
-      vpn_info = ec2.describe_vpn_connections(vpn_connection_ids: [config[:vpn_id]]).vpn_connection_set
+      ec2 = Aws::EC2::Client.new
+      vpn_info = ec2.describe_vpn_connections(vpn_connection_ids: [config[:vpn_id]]).vpn_connections
       down_connections = vpn_info.first.vgw_telemetry.select { |x| x.status != 'UP' }
       results = { down_count: down_connections.count }
-      results[:down_connection_status] = down_connections.map { |x| "#{x.outside_ip_address} => #{x.status_message.nil? ? 'none' : x.status_message}" }
-      results[:connection_name] = vpn_info[0].tag_set.find { |x| x.key == 'Name' }.value
-    rescue AWS::EC2::Errors::InvalidVpnConnectionID::NotFound
+      results[:down_connection_status] = down_connections.map { |x| "#{x.outside_ip_address} => #{x.status_message.empty? ? 'none' : x.status_message}" }
+      results[:connection_name] = vpn_info[0].tags.find { |x| x.key == 'Name' }.value
+    rescue Aws::EC2::Errors::ServiceError
       warning "The vpnConnection ID '#{config[:vpn_id]}' does not exist"
     rescue => e
       warning e.backtrace.join(' ')
@@ -92,12 +82,17 @@ class CheckAwsVpcVpnConnections < Sensu::Plugin::Check::CLI
     msg = data[:down_connection_status].join(' | ')
     name = data[:connection_name]
     case data[:down_count]
-    when 2 then critical "'#{name}' shows both tunnels as DOWN - [ #{msg} ]"
-    when 1 then warning "'#{name}' shows 1 of 2 tunnels as DOWN - [ #{msg} ]"
-    when 0 then ok "'#{name}' shows 2 of 2 tunnels as UP"
+    when 2 then message = "'#{name}' shows both tunnels as DOWN - [ #{msg} ]"
+    when 1 then message = "'#{name}' shows 1 of 2 tunnels as DOWN - [ #{msg} ]"
+    end
+
+    if data[:down_count] >= config[:crit_count]
+      critical message
+    elsif data[:down_count] >= config[:warn_count]
+      warning message
     else
-      # Not sure this could ever happen
-      unknown "Unknown connection count - #{data[:down_count]}"
+      up_count = 2 - data[:down_count]
+      ok "'#{name}' shows #{up_count} of 2 tunnels as UP"
     end
   end
 end

data/bin/metrics-asg.rb

@@ -0,0 +1,156 @@
+#! /usr/bin/env ruby
+#
+# asg-metrics
+#
+# DESCRIPTION:
+#   Gets latency metrics from CloudWatch and puts them in Graphite for longer term storage
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#   gem: sensu-plugin-aws
+#   gem: time
+#
+# USAGE:
+#
+#
+# NOTES:
+#   Returns latency statistics by default.  You can specify any valid ASG metric type, see
+#   http://http://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/as-metricscollected.html
+#
+# 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/metric/cli'
+require 'aws-sdk'
+require 'sensu-plugins-aws'
+require 'time'
+
+class ASGMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  include Common
+  option :asgname,
+         description: 'Name of the Auto Scaling Group',
+         short: '-n ASG_NAME',
+         long: '--name ASG_NAME'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: ''
+
+  option :fetch_age,
+         description: 'How long ago to fetch metrics for',
+         short: '-f AGE',
+         long: '--fetch_age',
+         default: 60,
+         proc: proc(&:to_i)
+
+  option :metric,
+         description: 'Metric to fetch',
+         short: '-m METRIC',
+         long: '--metric',
+         default: 'GroupInServiceInstances'
+
+  option :statistic,
+         description: 'Statistics type',
+         short: '-t STATISTIC',
+         long: '--statistic',
+         default: ''
+
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default: ENV['AWS_REGION']
+
+  option :end_time,
+         short:       '-t T',
+         long:        '--end-time TIME',
+         default:     Time.now,
+         proc:        proc { |a| Time.parse a },
+         description: 'CloudWatch metric statistics end time'
+
+  option :period,
+         short:       '-p N',
+         long:        '--period SECONDS',
+         default:     60,
+         proc:        proc(&:to_i),
+         description: 'CloudWatch metric statistics period'
+
+  def cloud_watch
+    @cloud_watch = Aws::CloudWatch::Client.new
+  end
+
+  def asg
+    @asg = Aws::AutoScaling::Client.new
+  end
+
+  def cloud_watch_metric(metric_name, value, asg_name)
+    cloud_watch.get_metric_statistics(
+      namespace: 'AWS/AutoScaling',
+      metric_name: metric_name,
+      dimensions: [
+        {
+          name: 'AutoScaling',
+          value: asg_name
+        }
+      ],
+      statistics: [value],
+      start_time: config[:end_time] - config[:period],
+      end_time: config[:end_time],
+      period: config[:period]
+    )
+  end
+
+  def print_statistics(asg_name, statistics)
+    result = {}
+    static_value = {}
+    statistics.each do |key, static|
+      r = cloud_watch_metric(key, static, asg_name)
+      static_value['AutoScalingGroup.' + asg_name + '.' + key + '.' + static] = static
+      result['AutoScalingGroup.' + asg_name + '.' + key + '.' + static] = r[:datapoints][0] unless r[:datapoints][0].nil?
+    end
+    result.each do |key, value|
+      output key.downcase.to_s, value[static_value[key].downcase], value[:timestamp].to_i
+    end
+  end
+
+  def run
+    if config[:statistic] == ''
+      default_statistic_per_metric = {
+        'GroupMinSize' => 'Sum',
+        'GroupMaxSize' => 'Sum',
+        'GroupDesiredCapacity' => 'Sum',
+        'GroupInServiceInstances' => 'Sum',
+        'GroupPendingInstances' => 'Sum',
+        'GroupStandbyInstances' => 'Sum',
+        'GroupTerminatingInstances' => 'Sum',
+        'GroupTotalInstances' => 'Sum'
+      }
+      statistic = default_statistic_per_metric
+    else
+      statistic = config[:statistic]
+    end
+
+    begin
+      if config[:asgname].nil?
+        asg.describe_auto_scaling_groups.auto_scaling_groups.each do |autoascalinggroup|
+          print_statistics(autoascalinggroup.auto_scaling_group_name, statistic)
+        end
+      else
+        print_statistics(config[:asgname], statistic)
+      end
+      ok
+    end
+  end
+end

data/bin/metrics-autoscaling-instance-count.rb

@@ -27,14 +27,14 @@
 #
 
 require 'sensu-plugin/metric/cli'
-require 'aws-sdk-v1'
+require 'aws-sdk'
 
 class AutoScalingInstanceCountMetrics < Sensu::Plugin::Metric::CLI::Graphite
   option :groupname,
          description: 'Name of the AutoScaling group',
          short: '-g GROUP_NAME',
          long: '--autoscaling-group GROUP_NAME',
-         required: true
+         default: false
 
   option :scheme,
          description: 'Metric naming scheme, text to prepend to metric',
@@ -60,22 +60,38 @@ class AutoScalingInstanceCountMetrics < Sensu::Plugin::Metric::CLI::Graphite
          description: 'AWS Region (defaults to us-east-1).',
          default: 'us-east-1'
 
+  option :include_name,
+         short: '-n',
+         long: '--include-name',
+         description: "Includes any offending instance's 'Name' tag in the metric output",
+         default: false
+
   def aws_config
     { access_key_id: config[:aws_access_key],
       secret_access_key: config[:aws_secret_access_key],
       region: config[:aws_region] }
   end
 
+  def autoscaling_groups
+    client = Aws::AutoScaling::Client.new(aws_config)
+    client.describe_auto_scaling_groups[:auto_scaling_groups].map(&:auto_scaling_group_name)
+  end
+
   def run
-    graphitepath = if config[:scheme] == ''
-                     "#{config[:groupname]}.autoscaling.instance_count"
-                   else
-                     config[:scheme]
-                   end
     begin
-      as = AWS::AutoScaling.new aws_config
-      count = as.groups[config[:groupname]].auto_scaling_instances.map(&:lifecycle_state).count('InService')
-      output graphitepath, count
+      groupnames ||= config[:groupname] ? [config[:groupname]] : autoscaling_groups
+      groupnames.each do |g|
+        as = Aws::AutoScaling::AutoScalingGroup.new aws_config.merge!(name: g)
+        count = as.instances.map(&:lifecycle_state).count('InService')
+        scheme_name ||= config[:include_name] ? as.data[:tags].select { |tag| tag[:key] == 'Name' }[0][:value] : g
+        graphitepath =
+          if config[:scheme] == ''
+            "#{scheme_name}.autoscaling.instance_count"
+          else
+            "#{config[:scheme]}.#{scheme_name}.instance_count"
+          end
+        output graphitepath, count
+      end
     rescue => e
       puts "Error: exception: #{e}"
       critical