sensu-plugins-aws 0.0.1.alpha.2

data/bin/ec2-count-metrics.rb

@@ -0,0 +1,144 @@
+#! /usr/bin/env ruby
+#
+# ec2-count-metrics
+#
+# DESCRIPTION:
+#   This plugin retrives number of EC2 status
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright (c) 2014, Tim Smith, tim@cozy.co
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'sensu-plugin/metric/cli'
+require 'aws-sdk'
+
+class EC2Metrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: 'sensu.aws.ec2'
+
+  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_ID'] or provide it as an option"
+
+  option :aws_secret_access_key,
+         short: '-k AWS_SECRET_ACCESS_KEY',
+         long: '--aws-secret-access-key AWS_SECRET_ACCESS_KEY',
+         description: "AWS Secret Access Key. Either set ENV['AWS_SECRET_ACCESS_KEY'] or provide it as an option"
+
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (such as us-east-1).',
+         default: 'us-east-1'
+
+  option :type,
+         short: '-t METRIC type',
+         long: '--type METRIC type',
+         description: 'Count by type: status, instance',
+         default: 'instance'
+
+  def aws_config
+    hash = {}
+    hash.update access_key_id: config[:access_key_id], secret_access_key: config[:secret_access_key] if config[:access_key_id] && config[:secret_access_key]
+    hash.update region: config[:aws_region]
+    hash
+  end
+
+  def run
+    begin
+
+      client = AWS::EC2::Client.new aws_config
+
+      def by_instances_status(client)
+        if config[:scheme] == 'sensu.aws.ec2'
+          config[:scheme] += '.count'
+        end
+
+        options = { include_all_instances: true }
+        data = client.describe_instance_status(options)
+
+        total = data[:instance_status_set].count
+        status = {}
+
+        unless total.nil?
+          data[:instance_status_set].each do |value|
+            stat = value[:instance_state][:name]
+            if status[stat].nil?
+              status[stat] = 1
+            else
+              status[stat] = status[stat] + 1
+            end
+          end
+        end
+
+        unless data.nil?
+          # We only return data when we have some to return
+          output config[:scheme] + '.total', total
+          status.each do |name, count|
+            output config[:scheme] + ".#{name}", count
+          end
+        end
+      end
+
+      def by_instances_type(client)
+        if config[:scheme] == 'sensu.aws.ec2'
+          config[:scheme] += '.types'
+        end
+
+        data = {}
+
+        instances = client.describe_instances
+        instances[:reservation_set].each do |i|
+          i[:instances_set].each do |instance|
+            type = instance[:instance_type]
+            if data[type].nil?
+              data[type] = 1
+            else
+              data[type] = data[type] + 1
+            end
+          end
+        end
+
+        unless data.nil?
+          # We only return data when we have some to return
+          data.each do |name, count|
+            output config[:scheme] + ".#{name}", count
+          end
+        end
+      end
+
+      if config[:type] == 'instance'
+        by_instances_type(client)
+      elsif config[:type] == 'status'
+        by_instances_status(client)
+      end
+
+    rescue => e
+      puts "Error: exception: #{e}"
+      critical
+    end
+    ok
+  end
+end

data/bin/ec2-node.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+#
+# CHANGELOG:
+# * 0.4.0:
+#   - Adds ability to specify a list of states an individual client can have in
+#     EC2. If none is specified, it filters out 'terminated' and 'stopped'
+#     instances by default.
+#   - Updates how we are "puts"-ing to the log.
+# * 0.3.0:
+#   - Updates handler to additionally filter stopped instances.
+# * 0.2.1:
+#   - Updates requested configuration snippets so they'll be redacted by
+#     default.
+# * 0.2.0:
+#   - Renames handler from chef_ec2_node to ec2_node
+#   - Removes Chef-related stuff from handler
+#   - Updates documentation
+# * 0.1.0:
+#   - Initial release
+#
+# This handler deletes a Sensu client if it's been stopped or terminated in EC2.
+# Optionally, you may specify a client attribute `ec2_states`, a list of valid
+# states an instance may have.
+#
+# NOTE: The implementation for correlating Sensu clients to EC2 instances may
+# need to be modified to fit your organization. The current implementation
+# assumes that Sensu clients' names are the same as their instance IDs in EC2.
+# If this is not the case, you can either sub-class this handler and override
+# `ec2_node_exists?` in your own organization-specific handler, or modify this
+# handler to suit your needs.
+#
+# Requires the following Rubygems (`gem install $GEM`):
+#   - sensu-plugin
+#   - fog
+#
+# Requires a Sensu configuration snippet:
+#   {
+#     "aws": {
+#       "access_key": "adsafdafda",
+#       "secret_key": "qwuieohajladsafhj23nm",
+#       "region": "us-east-1c"
+#     }
+#   }
+#
+# Or you can set the following environment variables:
+#   - AWS_ACCESS_KEY_ID
+#   - AWS_SECRET_ACCESS_KEY
+#   - EC2_REGION
+#
+#
+# To use, you can set it as the keepalive handler for a client:
+#   {
+#     "client": {
+#       "name": "i-424242",
+#       "address": "127.0.0.1",
+#       "keepalive": {
+#         "handler": "ec2_node"
+#       },
+#       "subscriptions": ["all"]
+#     }
+#   }
+#
+# You can also use this handler with a filter:
+#   {
+#     "filters": {
+#       "ghost_nodes": {
+#         "attributes": {
+#           "check": {
+#             "name": "keepalive",
+#             "status": 2
+#           },
+#           "occurences": "eval: value > 2"
+#         }
+#       }
+#     },
+#     "handlers": {
+#       "ec2_node": {
+#         "type": "pipe",
+#         "command": "/etc/sensu/handlers/ec2_node.rb",
+#         "severities": ["warning","critical"],
+#         "filter": "ghost_nodes"
+#       }
+#     }
+#   }
+#
+# Copyleft 2013 Yet Another Clever Name
+#
+# Based off of the `chef_node` handler by Heavy Water Operations, LLC
+#
+# Released under the same terms as Sensu (the MIT license); see
+# LICENSE for details
+
+require 'timeout'
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'sensu-handler'
+require 'fog'
+
+class Ec2Node < Sensu::Handler
+  def filter; end
+
+  def handle
+    # #YELLOW
+    unless ec2_node_exists? # rubocop:disable UnlessElse
+      delete_sensu_client!
+    else
+      puts "[EC2 Node] #{@event['client']['name']} appears to exist in EC2"
+    end
+  end
+
+  def delete_sensu_client!
+    response = api_request(:DELETE, '/clients/' + @event['client']['name']).code
+    deletion_status(response)
+  end
+
+  def ec2_node_exists?
+    states = acquire_valid_states
+    filtered_instances = ec2.servers.select { |s| states.include?(s.state) }
+    instance_ids = filtered_instances.map(&:id)
+    instance_ids.each do |id|
+      return true if id == @event['client']['name']
+    end
+    false # no match found, node doesn't exist
+  end
+
+  def ec2
+    @ec2 ||= begin
+      key = settings['aws']['access_key'] || ENV['AWS_ACCESS_KEY_ID']
+      secret = settings['aws']['secret_key'] || ENV['AWS_SECRET_ACCESS_KEY']
+      region = settings['aws']['region'] || ENV['EC2_REGION']
+      Fog::Compute.new(provider: 'AWS',
+                       aws_access_key_id: key,
+                       aws_secret_access_key: secret,
+                       region: region)
+    end
+  end
+
+  def deletion_status(code)
+    case code
+    when '202'
+      puts "[EC2 Node] 202: Successfully deleted Sensu client: #{node}"
+    when '404'
+      puts "[EC2 Node] 404: Unable to delete #{node}, doesn't exist!"
+    when '500'
+      puts "[EC2 Node] 500: Miscellaneous error when deleting #{node}"
+    else
+      puts "[EC2 Node] #{res}: Completely unsure of what happened!"
+    end
+  end
+
+  def acquire_valid_states
+    if @event['client'].key?('ec2_states')
+      return @event['client']['ec2_states']
+    else
+      return ['running']
+    end
+  end
+end

data/bin/elasticache-metrics.rb

@@ -0,0 +1,200 @@
+#! /usr/bin/env ruby
+#
+# elasticache-metrics
+#
+# DESCRIPTION:
+#   Fetch Elasticache metrics from CloudWatch
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: aws-sdk
+#   gem: sensu-plugin
+#
+# needs example command
+# USAGE:
+#   #YELLOW
+
+# NOTES:
+#   Redis: http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CacheMetrics.Redis.html
+#   Memcached: http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CacheMetrics.Memcached.html
+#
+#   By default fetches all available statistics from one minute ago.  You may need to fetch further back than this;
+#
+# LICENSE:
+#   Copyright 2014 Yann Verry
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'sensu-plugin/metric/cli'
+require 'aws-sdk'
+
+class ElastiCacheMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :cacheclusterid,
+         description: 'Name of the Cache Cluster',
+         short: '-n ELASTICACHE_NAME',
+         long: '--name ELASTICACHE_NAME',
+         required: true
+
+  option :cachenodeid,
+         description: 'Cache Node ID',
+         short: '-i CACHE_NODE_ID',
+         long: '--cache-node-id CACHE_NODE_ID',
+         default: '0001'
+
+  option :elasticachetype,
+         description: 'Elasticache type redis or memcached',
+         short: '-c TYPE',
+         long: '--cachetype TYPE',
+         required: true
+
+  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 :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_ID'] or provide it as an option"
+
+  option :aws_secret_access_key,
+         short: '-k AWS_SECRET_ACCESS_KEY',
+         long: '--aws-secret-access-key AWS_SECRET_ACCESS_KEY',
+         description: "AWS Secret Access Key. Either set ENV['AWS_SECRET_ACCESS_KEY'] or provide it as an option"
+
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (such as us-east-1).',
+         default: 'us-east-1'
+
+  def aws_config
+    hash = {}
+    hash.update access_key_id: config[:access_key_id], secret_access_key: config[:secret_access_key] if config[:access_key_id] && config[:secret_access_key]
+    hash.update region: config[:aws_region]
+    hash
+  end
+
+  def run
+    if config[:scheme] == ''
+      graphitepath = "#{config[:elasticachename]}.#{config[:metric].downcase}"
+    else
+      graphitepath = config[:scheme]
+    end
+
+    statistic_type = {
+      'redis' => {
+        'CPUUtilization' => 'Percent',
+        'SwapUsage' => 'Bytes',
+        'FreeableMemory' => 'Bytes',
+        'NetworkBytesIn' => 'Bytes',
+        'NetworkBytesOut' => 'Bytes',
+        'GetTypeCmds' => 'Count',
+        'SetTypeCmds' => 'Count',
+        'KeyBasedCmds' => 'Count',
+        'StringBasedCmds' => 'Count',
+        'HashBasedCmds' => 'Count',
+        'ListBasedCmds' => 'Count',
+        'SetBasedCmds' => 'Count',
+        'SortedSetBasedCmds' => 'Count',
+        'CurrItems' => 'Count'
+      },
+      'memcached' => {
+        'CPUUtilization' => 'Percent',
+        'SwapUsage' => 'Bytes',
+        'FreeableMemory' => 'Bytes',
+        'NetworkBytesIn' => 'Bytes',
+        'NetworkBytesOut' => 'Bytes',
+        'BytesUsedForCacheItems' => 'Bytes',
+        'BytesReadIntoMemcached' => 'Bytes',
+        'BytesWrittenOutFromMemcached' => 'Bytes',
+        'CasBadval' => 'Count',
+        'CasHits' => 'Count',
+        'CasMisses' => 'Count',
+        'CmdFlush' => 'Count',
+        'CmdGet' => 'Count',
+        'CmdSet' => 'Count',
+        'CurrConnections' => 'Count',
+        'CurrItems' => 'Count',
+        'DecrHits' => 'Count',
+        'DecrMisses' => 'Count',
+        'DeleteHits' => 'Count',
+        'DeleteMisses' => 'Count',
+        'Evictions' => 'Count',
+        'GetHits' => 'Count',
+        'GetMisses' => 'Count',
+        'IncrHits' => 'Count',
+        'IncrMisses' => 'Count',
+        'Reclaimed' => 'Count',
+        'BytesUsedForHash' => 'Bytes',
+        'CmdConfigGet' => 'Count',
+        'CmdConfigSet' => 'Count',
+        'CmdTouch' => 'Count',
+        'CurrConfig' => 'Count',
+        'EvictedUnfetched' => 'Count',
+        'ExpiredUnfetched' => 'Count',
+        'SlabsMoved' => 'Count',
+        'TouchHits' => 'Count',
+        'TouchMisses' => 'Count',
+        'NewConnections' => 'Count',
+        'NewItems' => 'Count',
+        'UnusedMemory' => 'Bytes'
+      }
+    }
+
+    begin
+      et = Time.now - config[:fetch_age]
+      st = et - 60
+
+      cw = AWS::CloudWatch::Client.new aws_config
+
+      # define all options
+      options = {
+        'namespace' => 'AWS/ElastiCache',
+        'metric_name' => config[:metric],
+        'dimensions' => [
+          { 'name' => 'CacheClusterId', 'value' => config[:cacheclusterid] }
+        ],
+        'start_time' => st.iso8601,
+        'end_time' => et.iso8601,
+        'period' => 60,
+        'statistics' => ['Average']
+      }
+
+      result = {}
+
+      # Fetch all metrics by elasticachetype (redis or memcached).
+      statistic_type[config[:elasticachetype]].each do |m|
+        options['metric_name'] = m[0] # override metric
+        r = cw.get_metric_statistics(options)
+        result[m[0]] = r[:datapoints][0] unless r[:datapoints][0].nil?
+      end
+
+      unless result.nil?
+        result.each do |name, d|
+          # We only return data when we have some to return
+          output graphitepath + '.' + name.downcase, d[:average], d[:timestamp].to_i
+        end
+      end
+    rescue => e
+      puts "Error: exception: #{e}"
+      critical
+    end
+    ok
+  end
+end

data/bin/elb-full-metrics.rb

@@ -0,0 +1,144 @@
+#! /usr/bin/env ruby
+#
+# elb-full-metrics
+#
+# DESCRIPTION:
+#   Gets latency metrics from CloudWatch and puts them in Graphite for longer term storage
+#
+# OUTPUT:
+#   metric-data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# 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.
+#
+
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+require 'sensu-plugin/metric/cli'
+require 'aws-sdk'
+
+class ELBMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  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: ''
+
+  option :fetch_age,
+         description: 'How long ago to fetch metrics for',
+         short: '-f AGE',
+         long: '--fetch_age',
+         default: 60,
+         proc: proc(&:to_i)
+
+  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",
+         required: true,
+         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",
+         required: true,
+         default: ENV['AWS_SECRET_KEY']
+
+  option :aws_region,
+         short: '-r AWS_REGION',
+         long: '--aws-region REGION',
+         description: 'AWS Region (such as eu-west-1).',
+         default: 'us-east-1'
+
+  def aws_config
+    hash = {}
+    hash.update access_key_id: config[:access_key_id], secret_access_key: config[:secret_access_key] if config[:access_key_id] && config[:secret_access_key]
+    hash.update region: config[:aws_region]
+    hash
+  end
+
+  def run
+    statistic_type = {
+      'Latency' => 'Average',
+      'RequestCount' => 'Sum',
+      'UnHealthyHostCount' => 'Average',
+      'HealthyHostCount' => 'Average',
+      'HTTPCode_Backend_2XX' => 'Sum',
+      'HTTPCode_Backend_4XX' => 'Sum',
+      'HTTPCode_Backend_5XX' => 'Sum',
+      'HTTPCode_ELB_4XX' => 'Sum',
+      'HTTPCode_ELB_5XX' => 'Sum'
+    }
+
+    begin
+      et = Time.now - config[:fetch_age]
+      st = et - 60
+
+      cw = AWS::CloudWatch::Client.new aws_config
+
+      options = {
+        'namespace' => 'AWS/ELB',
+        'dimensions' => [
+          {
+            'name' => 'LoadBalancerName',
+            'value' => config[:elbname]
+          }
+        ],
+        'start_time' => st.iso8601,
+        'end_time' => et.iso8601,
+        'period' => 60
+      }
+
+      result = {}
+      graphitepath = config[:scheme]
+
+      config[:elbname].split(' ').each do |elbname|
+        statistic_type.each do |key, value|
+          if config[:scheme] == ''
+            graphitepath = "#{config[:elbname]}.#{key.downcase}"
+          end
+          options['metric_name'] = key
+          options['dimensions'][0]['value'] = elbname
+          options['statistics'] = [value]
+          r = cw.get_metric_statistics(options)
+          result[key] = r[:datapoints][0] unless r[:datapoints][0].nil?
+        end
+        unless result.nil?
+          # We only return data when we have some to return
+          result.each do |key, value|
+            puts key, value
+            output graphitepath + ".#{key}", value.to_a.last[1], value[:timestamp].to_i
+          end
+        end
+      end
+    rescue => e
+      critical "Error: exception: #{e}"
+    end
+    ok
+  end
+end