sensu-plugins-aws-boutetnico 1.0.6

data/bin/handler-ses.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+#
+#
+# This handler formats alerts as mails and sends them off to a pre-defined recipient.
+#
+# Requires the aws-sdk gem.
+#
+# Setting required in ses.json
+#
+# Released under the same terms as Sensu (the MIT license); see LICENSE
+# for details.
+
+require 'sensu-handler'
+require 'aws-sdk'
+
+class SESNotifier < Sensu::Handler
+  def event_name
+    @event['client']['name'] + '/' + @event['check']['name']
+  end
+
+  def action_to_string
+    @event['action'].eql?('resolve') ? 'RESOLVED' : 'ALERT'
+  end
+
+  def status_to_string
+    case @event['check']['status']
+    when 0
+      'OK'
+    when 1
+      'WARNING'
+    when 2
+      'CRITICAL'
+    else
+      'UNKNOWN'
+    end
+  end
+
+  def mail_from
+    settings['ses']['mail_from'] || ''
+  end
+
+  def build_mail_to_list
+    json_config = config[:json_config] || 'ses'
+    mail_to = @event['check']['mail_to'] || @event['client']['mail_to'] || settings[json_config]['mail_to']
+    if settings[json_config].key?('subscriptions')
+      @event['check']['subscribers'].each do |sub|
+        if settings[json_config]['subscriptions'].key?(sub)
+          mail_to << ", #{settings[json_config]['subscriptions'][sub]['mail_to']}"
+        end
+      end
+    end
+    mail_to
+  end
+
+  def region
+    settings['ses']['region'] || 'us-east-1'
+  end
+
+  def handle
+    mail_to = build_mail_to_list
+    body = <<-BODY.gsub(/^\s+/, '')
+            #{@event['check']['output']}
+            Host: #{@event['client']['name']}
+            Timestamp: #{Time.at(@event['check']['issued'])}
+            Address:  #{@event['client']['address']}
+            Check Name:  #{@event['check']['name']}
+            Command:  #{@event['check']['command']}
+            Status:  #{@event['check']['status']}
+            Occurrences:  #{@event['occurrences']}
+          BODY
+
+    subject = if @event['check']['notification'].nil?
+                "#{action_to_string} - #{event_name}: #{status_to_string}"
+              else
+                "#{action_to_string} - #{event_name}: #{@event['check']['notification']}"
+              end
+
+    message = {
+      subject: {
+        data: subject
+      },
+      body: {
+        text: {
+          data: body
+        }
+      }
+    }
+
+    ses = Aws::SES::Client.new(region: region)
+
+    begin
+      Timeout.timeout(10) do
+        ses.send_email(
+          source: mail_from,
+          destination: {
+            to_addresses: mail_to.split(',')
+          },
+          message: message
+        )
+
+        puts 'mail -- sent alert for ' + event_name + ' to ' + mail_to.to_s
+      end
+    rescue Timeout::Error
+      puts 'mail -- timed out while attempting to ' + @event['action'] + ' an incident -- ' + event_name
+    end
+  end
+end

data/bin/handler-sns.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+#
+# Send notifications to an SNS topic
+#
+# Requires the aws-sdk gem.
+#
+# See README for usage information
+#
+# Released under the same terms as Sensu (the MIT license); see LICENSE
+# for details
+
+require 'sensu-handler'
+require 'aws-sdk'
+require 'erubis'
+
+class SnsNotifier < Sensu::Handler
+  def topic_arn
+    settings['sns']['topic_arn']
+  end
+
+  def region
+    settings['sns']['region'] || 'us-east-1'
+  end
+
+  def event_name
+    "#{@event['client']['name']}/#{@event['check']['name']}"
+  end
+
+  def message
+    template = if template_file && File.readable?(template_file)
+                 File.read(template_file)
+               else
+                 <<-BODY.gsub(/^\s+/, '')
+        <%= @event['check']['notification'] || @event['check']['output'] %>
+      BODY
+               end
+    eruby = Erubis::Eruby.new(template)
+    eruby.result(binding)
+  end
+
+  def template_file
+    settings['sns']['template_file']
+  end
+
+  def handle
+    sns = Aws::SNS::Client.new(region: region)
+
+    subject = if @event['action'].eql?('resolve')
+                "RESOLVED - [#{event_name}]"
+              else
+                "ALERT - [#{event_name}]"
+              end
+
+    options = {
+      subject: subject,
+      message: "#{subject} - #{message}",
+      topic_arn: topic_arn
+    }
+
+    sns.publish(options)
+  rescue StandardError => e
+    puts "Exception occured in SnsNotifier: #{e.message}", e.backtrace
+  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
+#   https://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'
+
+  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: 'Statistic type',
+         short: '-t STATISTIC',
+         long: '--statistic',
+         default: 'Sum'
+
+  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: 'AutoScalingGroupName',
+          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 = {}
+    statistics.each do |key, static|
+      r = cloud_watch_metric(key, static, asg_name)
+      keys =
+        if config[:scheme].nil?
+          []
+        else
+          [config[:scheme]]
+        end
+      keys.concat ['AutoScalingGroup', asg_name.tr(' ', '_'), key, static]
+
+      result[keys.join('.')] = r[:datapoints].first unless r[:datapoints].first.nil?
+    end
+    result.each do |key, value|
+      output key.downcase.to_s, value[config[:statistic].downcase], value[:timestamp].to_i
+    end
+  end
+
+  def run
+    statistic = {
+      'GroupMinSize' => config[:statistic],
+      'GroupMaxSize' => config[:statistic],
+      'GroupDesiredCapacity' => config[:statistic],
+      'GroupInServiceInstances' => config[:statistic],
+      'GroupPendingInstances' => config[:statistic],
+      'GroupStandbyInstances' => config[:statistic],
+      'GroupTerminatingInstances' => config[:statistic],
+      'GroupTotalInstances' => config[:statistic]
+    }
+
+    begin
+      if config[:asgname].nil?
+        asg.describe_auto_scaling_groups.auto_scaling_groups.each do |autoscalinggroup|
+          print_statistics(autoscalinggroup.auto_scaling_group_name, statistic)
+        end
+      else
+        print_statistics(config[:asgname], statistic)
+      end
+      ok
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+#! /usr/bin/env ruby
+#
+# metrics-autoscaling-instance-count
+#
+# DESCRIPTION:
+#   Get a count of instances in a given AutoScaling group
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk-v1
+#   gem: sensu-plugin
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2013 Bashton Ltd http://www.bashton.com/
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/metric/cli'
+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',
+         default: false
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: ''
+
+  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 :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
+    begin
+      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 StandardError => e
+      puts "Error: exception: #{e}"
+      critical
+    end
+    ok
+  end
+end

data/bin/metrics-billing.rb

@@ -0,0 +1,97 @@
+#! /usr/bin/env ruby
+#
+# s3-billing
+#
+# DESCRIPTION:
+#   Gets Billing 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-plugins-aws
+#
+# USAGE:
+#   metrics-billing.rb
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright (c) 2015, Olivier Bazoud, olivier.bazoud@gmail.com
+#   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'
+
+class BillingMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  include Common
+
+  option :services_name,
+         short: '-S SERVICES_NAME',
+         long: '--services-name SERVICES_NAME',
+         description: 'The name of the AWS service (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/billing-metricscollected.html)',
+         default: 'AmazonEC2,AWSDataTransfer'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: 'sensu.aws.billing'
+
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default: 'us-east-1'
+
+  def run
+    begin
+      cw = Aws::CloudWatch::Client.new(aws_config)
+      now = Time.now
+      r = cw.get_metric_statistics(
+        namespace: 'AWS/Billing',
+        metric_name: 'EstimatedCharges',
+        dimensions: [
+          {
+            name: 'Currency',
+            value: 'USD'
+          }
+        ],
+        start_time: (now.utc - 6 * 60 * 60).iso8601,
+        end_time: now.utc.iso8601,
+        period: 6 * 60 * 60,
+        statistics: ['Maximum'],
+        unit: 'None'
+      )
+      output "#{config[:scheme]}.total.estimated_charges", r[:datapoints][0].maximum, r[:datapoints][0][:timestamp].to_i unless r[:datapoints][0].nil?
+
+      config[:services_name].split(',').each do |service_name|
+        r = cw.get_metric_statistics(
+          namespace: 'AWS/Billing',
+          metric_name: 'EstimatedCharges',
+          dimensions: [
+            { name: 'Currency', value: 'USD' },
+            { name: 'ServiceName', value: service_name }
+          ],
+          start_time: (now.utc - 6 * 60 * 60).iso8601,
+          end_time: now.utc.iso8601,
+          period: 6 * 60 * 60,
+          statistics: ['Maximum'],
+          unit: 'None'
+        )
+        output "#{config[:scheme]}.total.#{service_name}", r[:datapoints][0].maximum, r[:datapoints][0][:timestamp].to_i unless r[:datapoints][0].nil?
+      end
+    rescue StandardError => e
+      critical "Error: exception: #{e}"
+    end
+    ok
+  end
+end