sensu-plugins-elasticsearch-boutetnico 1.0.4

data/bin/check-es-file-descriptors.rb

@@ -0,0 +1,173 @@
+#! /usr/bin/env ruby
+#
+#   check-es-file-descriptors
+#
+# DESCRIPTION:
+#   This plugin checks the ElasticSearch file descriptor usage, using its API.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: rest-client
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   Author: S. Zachariah Sprackett <zac@sprackett.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'rest-client'
+require 'json'
+require 'base64'
+
+#
+# ES File Descriptiors
+#
+class ESFileDescriptors < Sensu::Plugin::Check::CLI
+  option :host,
+         description: 'Elasticsearch host',
+         short: '-h HOST',
+         long: '--host HOST',
+         default: 'localhost'
+
+  option :port,
+         description: 'Elasticsearch port',
+         short: '-p PORT',
+         long: '--port PORT',
+         proc: proc(&:to_i),
+         default: 9200
+
+  option :timeout,
+         description: 'Sets the connection timeout for REST client',
+         short: '-t SECS',
+         long: '--timeout SECS',
+         proc: proc(&:to_i),
+         default: 30
+
+  option :critical,
+         description: 'Critical percentage of FD usage',
+         short: '-c PERCENTAGE',
+         proc: proc(&:to_i),
+         default: 90
+
+  option :warning,
+         description: 'Warning percentage of FD usage',
+         short: '-w PERCENTAGE',
+         proc: proc(&:to_i),
+         default: 80
+
+  option :user,
+         description: 'Elasticsearch User',
+         short: '-u USER',
+         long: '--user USER'
+
+  option :password,
+         description: 'Elasticsearch Password',
+         short: '-P PASS',
+         long: '--password PASS'
+
+  option :https,
+         description: 'Enables HTTPS',
+         short: '-e',
+         long: '--https'
+
+  option :cert_file,
+         description: 'Cert file to use',
+         long: '--cert-file CERT'
+
+  def get_es_resource(resource)
+    headers = {}
+    if config[:user] && config[:password]
+      auth = 'Basic ' + Base64.strict_encode64("#{config[:user]}:#{config[:password]}").chomp
+      headers = { 'Authorization' => auth }
+    end
+
+    protocol = if config[:https]
+                 'https'
+               else
+                 'http'
+               end
+
+    r = if config[:cert_file]
+          RestClient::Resource.new("#{protocol}://#{config[:host]}:#{config[:port]}#{resource}",
+                                   ssl_ca_file: config[:cert_file].to_s,
+                                   timeout: config[:timeout],
+                                   headers: headers)
+        else
+          RestClient::Resource.new("#{protocol}://#{config[:host]}:#{config[:port]}#{resource}",
+                                   timeout: config[:timeout],
+                                   headers: headers)
+        end
+    JSON.parse(r.get)
+  rescue Errno::ECONNREFUSED
+    warning 'Connection refused'
+  rescue RestClient::RequestTimeout
+    warning 'Connection timed out'
+  rescue RestClient::ServiceUnavailable
+    warning 'Service is unavailable'
+  end
+
+  def acquire_es_version
+    info = get_es_resource('/')
+    info['version']['number']
+  end
+
+  def es_version
+    @es_version ||= Gem::Version.new(acquire_es_version)
+  end
+
+  def acquire_open_fds
+    stats = if es_version < Gem::Version.new('5.0.0')
+              get_es_resource('/_nodes/_local/stats?process=true')
+            else
+              get_es_resource('/_nodes/_local/stats/process')
+            end
+    begin
+      keys = stats['nodes'].keys
+      stats['nodes'][keys[0]]['process']['open_file_descriptors'].to_i
+    rescue NoMethodError
+      warning 'Failed to retrieve open_file_descriptors'
+    end
+  end
+
+  def acquire_max_fds
+    info = if es_version < Gem::Version.new('2.0.0')
+             get_es_resource('/_nodes/_local?process=true')
+           elsif es_version < Gem::Version.new('5.0.0')
+             get_es_resource('/_nodes/_local/stats?process=true')
+           else
+             get_es_resource('/_nodes/_local/stats/process')
+           end
+    begin
+      keys = info['nodes'].keys
+      info['nodes'][keys[0]]['process']['max_file_descriptors'].to_i
+    rescue NoMethodError
+      warning 'Failed to retrieve max_file_descriptors'
+    end
+  end
+
+  def run
+    open = acquire_open_fds
+    max = acquire_max_fds
+    used_percent = ((open.to_f / max.to_f) * 100).to_i
+
+    if used_percent >= config[:critical]
+      critical "fd usage #{used_percent}% exceeds #{config[:critical]}% (#{open}/#{max})"
+    elsif used_percent >= config[:warning]
+      warning "fd usage #{used_percent}% exceeds #{config[:warning]}% (#{open}/#{max})"
+    else
+      ok "fd usage at #{used_percent}% (#{open}/#{max})"
+    end
+  end
+end

data/bin/check-es-heap.rb

@@ -0,0 +1,205 @@
+#! /usr/bin/env ruby
+#
+#   check-es-heap
+#
+# DESCRIPTION:
+#   This plugin checks ElasticSearch's Java heap usage using its API.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: rest-client
+#
+# USAGE:
+#   example commands
+#
+# NOTES:
+#
+# LICENSE:
+#  Copyright 2012 Sonian, Inc <chefs@sonian.net>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'rest-client'
+require 'json'
+require 'base64'
+
+#
+# ES Heap
+#
+class ESHeap < Sensu::Plugin::Check::CLI
+  option :host,
+         description: 'Elasticsearch host',
+         short: '-h HOST',
+         long: '--host HOST',
+         default: 'localhost'
+
+  option :port,
+         description: 'Elasticsearch port',
+         short: '-p PORT',
+         long: '--port PORT',
+         proc: proc(&:to_i),
+         default: 9200
+
+  option :warn,
+         short: '-w N',
+         long: '--warn N',
+         description: 'Heap used in bytes WARNING threshold',
+         proc: proc(&:to_i),
+         default: 0
+
+  option :timeout,
+         description: 'Sets the connection timeout for REST client',
+         short: '-t SECS',
+         long: '--timeout SECS',
+         proc: proc(&:to_i),
+         default: 30
+
+  option :crit,
+         short: '-c N',
+         long: '--crit N',
+         description: 'Heap used in bytes CRITICAL threshold',
+         proc: proc(&:to_i),
+         default: 0
+
+  option :percentage,
+         short: '-P',
+         long: '--percentage',
+         description: 'Use the WARNING and CRITICAL threshold numbers as percentage indicators of the total heap available',
+         default: false
+
+  option :user,
+         description: 'Elasticsearch User',
+         short: '-u USER',
+         long: '--user USER'
+
+  option :password,
+         description: 'Elasticsearch Password',
+         short: '-W PASS',
+         long: '--password PASS'
+
+  option :https,
+         description: 'Enables HTTPS',
+         short: '-e',
+         long: '--https'
+
+  option :cert_file,
+         description: 'Cert file to use',
+         long: '--cert-file CERT'
+
+  option :all,
+         description: 'Check all nodes in the ES cluster',
+         short: '-a',
+         long: '--all',
+         default: false
+
+  def acquire_es_version
+    info = acquire_es_resource('/')
+    info['version']['number']
+  end
+
+  def acquire_es_resource(resource)
+    headers = {}
+    if config[:user] && config[:password]
+      auth = 'Basic ' + Base64.strict_encode64("#{config[:user]}:#{config[:password]}").chomp
+      headers = { 'Authorization' => auth }
+    end
+
+    protocol = if config[:https]
+                 'https'
+               else
+                 'http'
+               end
+
+    r = if config[:cert_file]
+          RestClient::Resource.new("#{protocol}://#{config[:host]}:#{config[:port]}#{resource}",
+                                   ssl_ca_file: config[:cert_file].to_s,
+                                   timeout: config[:timeout],
+                                   headers: headers)
+        else
+          RestClient::Resource.new("#{protocol}://#{config[:host]}:#{config[:port]}#{resource}",
+                                   timeout: config[:timeout],
+                                   headers: headers)
+        end
+    JSON.parse(r.get)
+  rescue Errno::ECONNREFUSED
+    warning 'Connection refused'
+  rescue RestClient::RequestTimeout
+    warning 'Connection timed out'
+  rescue RestClient::ServiceUnavailable
+    warning 'Service is unavailable'
+  rescue JSON::ParserError
+    warning 'Elasticsearch API returned invalid JSON'
+  end
+
+  def acquire_stats
+    if Gem::Version.new(acquire_es_version) >= Gem::Version.new('1.0.0')
+      if config[:all]
+        acquire_es_resource('/_nodes/stats')
+      else
+        acquire_es_resource('/_nodes/_local/stats')
+      end
+    elsif config[:all]
+      acquire_es_resource('/_cluster/nodes/stats')
+    else
+      acquire_es_resource('/_cluster/nodes/_local/stats')
+    end
+  end
+
+  def acquire_heap_data(node)
+    return node['jvm']['mem']['heap_used_in_bytes'], node['jvm']['mem']['heap_max_in_bytes']
+  rescue StandardError
+    warning 'Failed to obtain heap used in bytes'
+  end
+
+  def acquire_heap_usage(heap_used, heap_max, node_name)
+    if config[:percentage]
+      heap_usage = ((100 * heap_used) / heap_max).to_i
+      output = if config[:all]
+                 "Node #{node_name}: Heap used in bytes #{heap_used} (#{heap_usage}% full)\n"
+               else
+                 "Heap used in bytes #{heap_used} (#{heap_usage}% full)"
+               end
+    else
+      heap_usage = heap_used
+      output = config[:all] ? "Node #{node_name}: Heap used in bytes #{heap_used}\n" : "Heap used in bytes #{heap_used}"
+    end
+    [heap_usage, output]
+  end
+
+  def run
+    stats = acquire_stats
+    status = { crit: '', warn: '', ok: '' }
+
+    # Check all the nodes in the cluster, alert if any of the nodes have heap usage above thresholds
+    stats['nodes'].each_value do |node|
+      heap_used, heap_max = acquire_heap_data(node)
+      heap_usage, output = acquire_heap_usage(heap_used, heap_max, node['name'])
+      if heap_usage >= config[:crit]
+        status[:crit] += output
+      elsif heap_usage >= config[:warn]
+        status[:warn] += output
+      elsif !config[:all]
+        status[:ok] += output
+      end
+    end
+
+    if !status[:crit].empty?
+      message status[:crit]
+      critical
+    elsif !status[:warn].empty?
+      message status[:warn]
+      warning
+    else
+      message status[:ok]
+      ok
+    end
+  end
+end

data/bin/check-es-indexes.rb

@@ -0,0 +1,89 @@
+#! /usr/bin/env ruby
+#
+# Check Elastic Search Indexes
+# ===
+#
+# DESCRIPTION:
+#   This plugin will check a a node for dupe indexes
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# needs usage
+# USAGE:
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2014 Yieldbot, Inc  <devops@yieldbot.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+
+#
+# == Check Elastic Search Cluster Index
+#
+class CheckESClusterIndex < Sensu::Plugin::Check::CLI
+  option :cluster,
+         description: 'Array of clusters to check',
+         short: '-C CLUSTER[,CLUSTER]',
+         long: '--cluster CLUSTER[,CLUSTER]',
+         proc: proc { |a| a.split(',') }
+
+  option :ignore,
+         description: 'Comma separated list of indexes to ignore',
+         short: '-i INDEX[,INDEX]',
+         long: '--ignore INDEX[,INDEX]',
+         proc: proc { |a| a.split(',') }
+
+  option :debug,
+         description: 'Debug',
+         short: '-d',
+         long: '--debug'
+
+  def run
+    # If only one cluster is given, no need to check the indexes
+    ok 'All indexes are unique' if config[:cluster].length == 1
+
+    port = ':9200'
+    cmd = '/_cat/indices?v | tail -n +2'
+
+    valid_index = {}
+    dupe_index = {}
+    config[:cluster].each do |u|
+      index_arr = `curl -s #{ u }#{ port }#{ cmd }`.split("\n")
+      index_arr.each do |t|
+        t = t.split[1]
+
+        # If the index is in the ignore list, go to the next one
+        next if config[:ignore].include? t
+
+        if valid_index.key?(t)
+          dupe_index[t] = [] unless dupe_index[t].is_a?(Array)
+          dupe_index[t] << u
+          dupe_index[t] << valid_index[t] unless dupe_index[t]
+                                                 .include?(valid_index[t])
+        else
+          valid_index[t] = [] unless valid_index[t].is_a?(Array)
+          valid_index[t] << u
+        end
+      end
+    end
+
+    if dupe_index.count > 0
+      dupe_index.each do |k, v|
+        critical "#{k} is on #{v}"
+      end
+    else
+      ok 'All indexes are unique'
+    end
+  end
+end