sensu-plugins-aws-boutetnico 1.0.6

data/bin/metrics-elb.rb

@@ -0,0 +1,169 @@
+#! /usr/bin/env ruby
+#
+# elb-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:
+#   #YELLOW
+#
+# NOTES:
+#   Returns latency statistics by default.  You can specify any valid ELB metric type, see
+#   http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html#elb-metricscollected
+#
+#   By default fetches statistics from one minute ago.  You may need to fetch further back than this;
+#   high traffic ELBs can sometimes experience statistic delays of up to 10 minutes.  If you experience this,
+#   raising a ticket with AWS support should get the problem resolved.
+#   As a workaround you can use eg -f 300 to fetch data from 5 minutes ago.
+#
+# LICENSE:
+#   Copyright 2013 Bashton Ltd http://www.bashton.com/
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#   Updated by Peter Hoppe <peter.hoppe.extern@bertelsmann.de> 09.11.2016
+#   Using aws sdk version 2
+
+require 'sensu-plugin/metric/cli'
+require 'aws-sdk'
+require 'sensu-plugins-aws'
+require 'time'
+
+class ELBMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  include Common
+  option :elbname,
+         description: 'Name of the Elastic Load Balancer',
+         short: '-n ELB_NAME',
+         long: '--name ELB_NAME'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: 'elb'
+
+  option :fetch_age,
+         description: 'How long ago to fetch metrics for',
+         short: '-f AGE',
+         long: '--fetch_age',
+         default: 60,
+         proc: proc(&:to_i)
+
+  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 loadbalancer
+    @loadbalancer = Aws::ElasticLoadBalancing::Client.new
+  end
+
+  def cloud_watch_metric(metric_name, value, load_balancer_name)
+    cloud_watch.get_metric_statistics(
+      namespace: 'AWS/ELB',
+      metric_name: metric_name,
+      dimensions: [
+        {
+          name: 'LoadBalancerName',
+          value: load_balancer_name
+        }
+      ],
+      statistics: [value],
+      start_time: config[:end_time] - config[:fetch_age] - config[:period],
+      end_time: config[:end_time] - config[:fetch_age],
+      period: config[:period]
+    )
+  end
+
+  def print_statistics(load_balancer_name, statistics)
+    result = {}
+    static_value = {}
+    statistics.each do |key, static|
+      r = cloud_watch_metric(key, static, load_balancer_name)
+      keys = if config[:scheme] == ''
+               []
+             else
+               [config[:scheme]]
+             end
+      keys.concat [load_balancer_name, key, static]
+      metric_key = keys.join('.')
+
+      static_value[metric_key] = static
+      result[metric_key] = 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 = {
+        'Latency' => 'Average',
+        'RequestCount' => 'Sum',
+        'UnHealthyHostCount' => 'Average',
+        'HealthyHostCount' => 'Average',
+        'HTTPCode_Backend_2XX' => 'Sum',
+        'HTTPCode_Backend_3XX' => 'Sum',
+        'HTTPCode_Backend_4XX' => 'Sum',
+        'HTTPCode_Backend_5XX' => 'Sum',
+        'HTTPCode_ELB_4XX' => 'Sum',
+        'HTTPCode_ELB_5XX' => 'Sum',
+        'BackendConnectionErrors' => 'Sum',
+        'SurgeQueueLength' => 'Maximum',
+        'SpilloverCount' => 'Sum'
+      }
+      statistic = default_statistic_per_metric
+    else
+      statistic = config[:statistic]
+    end
+
+    begin
+      if config[:elbname].nil?
+        loadbalancer.describe_load_balancers.load_balancer_descriptions.each do |elb|
+          print_statistics(elb.load_balancer_name, statistic)
+        end
+      else
+        print_statistics(config[:elbname], statistic)
+      end
+      ok
+    end
+  end
+end

data/bin/metrics-emr-steps.rb

@@ -0,0 +1,82 @@
+#! /usr/bin/env ruby
+#
+# metrics-emr-steps
+#
+# DESCRIPTION:
+#   Lists steps in EMR cluster queue with their status.
+#
+# OUTPUT:
+#   plain-text
+#
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   metric-emr-steps.rb -r us-west-2 -b 'prod lateral train'
+#
+#   This will list out the counts for each step status for the entire history of the cluster.
+#
+# NOTES:
+#
+# LICENSE:
+#   Bryan Absher <bryan.absher@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+
+require 'sensu-plugins-aws'
+require 'sensu-plugin/metric/cli'
+require 'aws-sdk'
+
+class EMRStepMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  include Common
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: 'sensu.aws.emr'
+
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default: 'us-east-1'
+
+  option :cluster_name,
+         short: '-b CLUSTER_NAME',
+         long: '--cluster-name',
+         description: 'The name of the EMR cluster',
+         required: true
+
+  def count(steps, status)
+    steps.count { |step| step.status.state == status }
+  end
+
+  STATUS = %w[PENDING RUNNING COMPLETED CANCELLED FAILED INTERRUPTED].freeze
+
+  def cluster_steps(emr, cluster_id, data)
+    steps = emr.list_steps(
+      cluster_id: cluster_id
+    ).steps
+    STATUS.each_entry { |s| data[s] += count(steps, s) }
+  end
+
+  def run
+    emr = Aws::EMR::Client.new(aws_config)
+    begin
+      emr_clusters = emr.list_clusters.clusters
+      clusters = emr_clusters.select { |c| c.name == config[:cluster_name] }
+      critical "EMR cluster #{config[:cluster_name]} not found" if clusters.empty?
+      cluster = clusters.sort_by { |c| c.status.timeline.creation_date_time }.reverse.first
+      data = {}
+      STATUS.each_entry { |status| data[status] = 0 }
+      cluster_steps(emr, cluster.id, data)
+      safe_name = config[:cluster_name].tr(' ', '_')
+      output config[:scheme] + '.' + safe_name + '.id.' + cluster.id
+      STATUS.each_entry { |status| output config[:scheme] + '.' + safe_name + '.step.' + status, data[status] }
+    end
+    ok
+  end
+end

data/bin/metrics-rds.rb

@@ -0,0 +1,153 @@
+#! /usr/bin/env ruby
+#
+# rds-metrics
+#
+# DESCRIPTION:
+#   Gets RDS metrics from CloudWatch and puts them in Graphite for longer term storage
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#   rds-metrics --aws-region eu-west-1
+#   rds-metrics --aws-region eu-west-1 --name sr2x8pbti0eon1
+#
+# NOTES:
+#   Returns all RDS statistics for all RDS instances in this account unless you specify --name
+#
+# 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/metric/cli'
+require 'aws-sdk'
+require 'time'
+
+class RDSMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  include Common
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME'
+
+  option :aws_region,
+         short:       '-r AWS_REGION',
+         long:        '--aws-region REGION',
+         description: 'AWS Region (defaults to us-east-1).',
+         default:     ENV['AWS_REGION']
+
+  option :db_instance_id,
+         short:       '-i N',
+         long:        '--db-instance-id NAME',
+         description: 'DB instance identifier'
+
+  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 :fetch_age,
+         description: 'How long ago to fetch metrics from',
+         short: '-f AGE',
+         long: '--fetch-age',
+         default: 0,
+         proc: proc(&:to_i)
+
+  option :period,
+         short:       '-p N',
+         long:        '--period SECONDS',
+         default:     60,
+         proc:        proc(&:to_i),
+         description: 'CloudWatch metric statistics period'
+
+  option :statistics,
+         short:       '-S N',
+         long:        '--statistics NAME',
+         default:     :average,
+         proc:        proc { |a| a.downcase.intern },
+         description: 'CloudWatch statistics method'
+
+  def rds
+    @rds = Aws::RDS::Client.new
+  end
+
+  def cloud_watch
+    @cloud_watch = Aws::CloudWatch::Client.new
+  end
+
+  def find_db_instance(id)
+    db = rds.describe_db_instances.db_instances.detect { |db_instance| db_instance.db_instance_identifier == id }
+    unknown 'DB instance not found.' if db.nil?
+    db
+  end
+
+  def cloud_watch_metric(metric_name, value)
+    cloud_watch.get_metric_statistics(
+      namespace: 'AWS/RDS',
+      metric_name: metric_name,
+      dimensions: [
+        {
+          name: 'DBInstanceIdentifier',
+          value: value
+        }
+      ],
+      start_time: config[:end_time] - config[:fetch_age] - config[:period],
+      end_time: config[:end_time] - config[:fetch_age],
+      statistics: [config[:statistics].to_s.capitalize],
+      period: config[:period]
+    )
+  end
+
+  def run
+    statistic_type = {
+      'CPUUtilization' => 'Average',
+      'DatabaseConnections' => 'Average',
+      'FreeStorageSpace' => 'Average',
+      'ReadIOPS' => 'Average',
+      'ReadLatency' => 'Average',
+      'ReadThroughput' => 'Average',
+      'WriteIOPS' => 'Average',
+      'WriteLatency' => 'Average',
+      'WriteThroughput' => 'Average',
+      'ReplicaLag' => 'Average',
+      'SwapUsage' => 'Average',
+      'BinLogDiskUsage' => 'Average',
+      'DiskQueueDepth' => 'Average'
+    }
+
+    @db_instance  = find_db_instance config[:db_instance_id]
+    @message      = "#{config[:db_instance_id]}: "
+
+    result = {}
+
+    rdsname = @db_instance.db_instance_identifier
+    full_scheme =
+      if config[:scheme].nil?
+        rdsname
+      else
+        config[:scheme] + '.' + rdsname
+      end
+
+    statistic_type.each_key do |key, _value|
+      r = cloud_watch_metric key, rdsname
+      result[full_scheme + '.' + key] = r[:datapoints][0] unless r[:datapoints][0].nil?
+    end
+    unless result.nil?
+      result.each do |key, value|
+        output key.downcase.to_s, value.average, value[:timestamp].to_i
+      end
+    end
+    exit
+  end
+end

data/bin/metrics-reservation-utilization.rb

@@ -0,0 +1,84 @@
+#! /usr/bin/env ruby
+#
+# reservation-utilization
+#
+# DESCRIPTION:
+#   Gets Reservation Utilization of an AWS account.
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#   gem: sensu-plugins-aws
+#
+# USAGE:
+#   metrics-reservation-utilization.rb
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright (c) 2019, Nicolas Boutet amd3002@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 ReservationUtilizationMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  include Common
+
+  option :from,
+         short:       '-f TIME',
+         long:        '--from TIME',
+         default:     Time.now - 2 * 86_400, # start date cannot be after 2 days ago
+         proc:        proc { |a| Time.parse a },
+         description: 'The beginning of the time period that you want the usage and costs for (inclusive).'
+
+  option :to,
+         short:       '-t TIME',
+         long:        '--to TIME',
+         default:     Time.now,
+         proc:        proc { |a| Time.parse a },
+         description: 'The end of the time period that you want the usage and costs for (exclusive).'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric.',
+         short:       '-s SCHEME',
+         long:        '--scheme SCHEME',
+         default:     'sensu.aws.reservation_utilization'
+
+  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
+      client = Aws::CostExplorer::Client.new(aws_config)
+
+      reservation_utilization = client.get_reservation_utilization(
+        time_period: {
+          start: config[:from].strftime('%Y-%m-%d'),
+          end: config[:to].strftime('%Y-%m-%d')
+        }
+      )
+
+      reservation_utilization.utilizations_by_time.each do |time|
+        time.total.to_h.each do |key, value|
+          output "#{config[:scheme]}.utilizations_by_time.#{key}", value, Time.parse(time.time_period.end).to_i
+        end
+      end
+    rescue StandardError => e
+      critical "Error: exception: #{e}"
+    end
+    ok
+  end
+end