sensu-plugins-graphite 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2a16c3bc084157cd55b7141a470cbf2ca12f711
+  data.tar.gz: f0742cb176d3eae355232ce7377a30d59639e837
+SHA512:
+  metadata.gz: f98e424b272955d83e69d0478c80dddbeb380c15db4d154da0f0b82e7eb28ccc9295d9833cc0d3558732d995e953be1dad90e4d76f9765442caf60e3861030c4
+  data.tar.gz: aa3554ccc1943cd78bac35ce23d416ca47c0c412a0f451e0018ff6eea8554e95bbaa7967997bee93a8b465afd54c500dba34a207fb822fa6913dd95303446430

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+#Change Log
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+This CHANGELOG follows the format listed at [Keep A Changelog](http://keepachangelog.com/)
+
+## Unreleased][unreleased]
+
+## 0.0.1 - 2015-04-30
+
+### Added
+- initial release
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sensu-Plugins
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,53 @@
+## Sensu-Plugins-graphite
+
+[![Build Status](https://travis-ci.org/sensu-plugins/sensu-plugins-graphite.svg?branch=master)](https://travis-ci.org/sensu-plugins/sensu-plugins-graphite)
+[![Gem Version](https://badge.fury.io/rb/sensu-plugins-graphite.svg)](http://badge.fury.io/rb/sensu-plugins-graphite)
+[![Code Climate](https://codeclimate.com/github/sensu-plugins/sensu-plugins-graphite/badges/gpa.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-graphite)
+[![Test Coverage](https://codeclimate.com/github/sensu-plugins/sensu-plugins-graphite/badges/coverage.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-graphite)
+[![Dependency Status](https://gemnasium.com/sensu-plugins/sensu-plugins-graphite.svg)](https://gemnasium.com/sensu-plugins/sensu-plugins-graphite)
+[![Codeship Status for sensu-plugins/sensu-plugins-graphite](https://codeship.com/projects/c6f4f5a0-db95-0132-445b-5ad94843e341/status?branch=master)](https://codeship.com/projects/79664)
+
+## Functionality
+
+## Files
+ * bin/check-graphite-data
+ * bin/check-graphite-replication
+ * bin/check-graphite-stats
+ * bin/check-graphite
+ * bin/extension-graphite
+ * bin/handlr-graphite-event
+ * bin/hanlder-graphite-notify
+ * bin/handler-graphite-occurances
+ * bin/mutator-graphite
+
+## Usage
+
+**handler-graphite-event**
+```
+{
+  "graphite_event": {
+    "server_uri": "https://graphite.example.com:443/events/",
+    "tags": [
+      "custom_tag_a",
+      "custom_tag_b"
+    ]
+  }
+}
+```
+
+**handler-graphite-occurances**
+```
+{
+ "graphite": {
+    "server":"graphite.example.com",
+    "port":"2003"
+ }
+}
+```
+
+## Installation
+
+[Installation and Setup](https://github.com/sensu-plugins/documentation/blob/master/user_docs/installation_instructions.md)
+
+## Notes
+

data/bin/check-graphite-data.rb

@@ -0,0 +1,257 @@
+#! /usr/bin/env ruby
+#
+#   check-data
+#
+# DESCRIPTION:
+#   This plugin checks values within graphite
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: json
+#   gem: open-uri
+#   gem: openssl
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2014 Sonian, Inc. and contributors. <support@sensuapp.org>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'json'
+require 'open-uri'
+require 'openssl'
+
+class CheckGraphiteData < Sensu::Plugin::Check::CLI
+  option :target,
+         description: 'Graphite data target',
+         short: '-t TARGET',
+         long: '--target TARGET',
+         required: true
+
+  option :server,
+         description: 'Server host and port',
+         short: '-s SERVER:PORT',
+         long: '--server SERVER:PORT',
+         required: true
+
+  option :username,
+         description: 'username for basic http authentication',
+         short: '-u USERNAME',
+         long: '--user USERNAME',
+         required: false
+
+  option :password,
+         description: 'user password for basic http authentication',
+         short: '-p PASSWORD',
+         long: '--pass PASSWORD',
+         required: false
+
+  option :passfile,
+         description: 'password file path for basic http authentication',
+         short: '-P PASSWORDFILE',
+         long: '--passfile PASSWORDFILE',
+         required: false
+
+  option :warning,
+         description: 'Generate warning if given value is above received value',
+         short: '-w VALUE',
+         long: '--warn VALUE',
+         proc: proc(&:to_f)
+
+  option :critical,
+         description: 'Generate critical if given value is above received value',
+         short: '-c VALUE',
+         long: '--critical VALUE',
+         proc: proc(&:to_f)
+
+  option :reset_on_decrease,
+         description: 'Send OK if value has decreased on any values within END-INTERVAL to END',
+         short: '-r INTERVAL',
+         long: '--reset INTERVAL',
+         proc: proc(&:to_i)
+
+  option :name,
+         description: 'Name used in responses',
+         short: '-n NAME',
+         long: '--name NAME',
+         default: 'graphite check'
+
+  option :allowed_graphite_age,
+         description: 'Allowed number of seconds since last data update (default: 60 seconds)',
+         short: '-a SECONDS',
+         long: '--age SECONDS',
+         default: 60,
+         proc: proc(&:to_i)
+
+  option :hostname_sub,
+         description: 'Character used to replace periods (.) in hostname (default: _)',
+         short: '-s CHARACTER',
+         long: '--host-sub CHARACTER'
+
+  option :from,
+         description: 'Get samples starting from FROM (default: -10mins)',
+         short: '-f FROM',
+         long: '--from FROM',
+         default: '-10mins'
+
+  option :below,
+         description: 'warnings/critical if values below specified thresholds',
+         short: '-b',
+         long: '--below'
+
+  option :no_ssl_verify,
+         description: 'Do not verify SSL certs',
+         short: '-v',
+         long: '--nosslverify'
+
+  option :help,
+         description: 'Show this message',
+         short: '-h',
+         long: '--help'
+
+  # Run checks
+  def run
+    if config[:help]
+      puts opt_parser if config[:help]
+      exit
+    end
+
+    data = retrieve_data
+    data.each_pair do |_key, value|
+      @value = value
+      @data = value['data']
+      check_age || check(:critical) || check(:warning)
+    end
+    ok("#{name} value okay")
+  end
+
+  # name used in responses
+  def name
+    base = config[:name]
+    @formatted ? "#{base} (#{@formatted})" : base
+  end
+
+  # Check the age of the data being processed
+  def check_age
+    # #YELLOW
+    if (Time.now.to_i - @value['end']) > config[:allowed_graphite_age] # rubocop:disable GuardClause
+      unknown "Graphite data age is past allowed threshold (#{config[:allowed_graphite_age]} seconds)"
+    end
+  end
+
+  # grab data from graphite
+  def retrieve_data
+    # #YELLOW
+    unless @raw_data # rubocop:disable GuardClause
+      begin
+        unless config[:server].start_with?('https://', 'http://')
+          config[:server].prepend('http://')
+        end
+
+        url = "#{config[:server]}/render?format=json&target=#{formatted_target}&from=#{config[:from]}"
+
+        url_opts = {}
+
+        if config[:no_ssl_verify]
+          url_opts[:ssl_verify_mode] = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        if config[:username] && (config[:password] || config[:passfile])
+          if config[:passfile]
+            pass = File.open(config[:passfile]).readline
+          elsif config[:password]
+            pass = config[:password]
+          end
+
+          url_opts[:http_basic_authentication] = [config[:username], pass.chomp]
+        end # we don't have both username and password trying without
+
+        handle = open(url, url_opts)
+
+        @raw_data = handle.gets
+        if @raw_data == '[]'
+          unknown 'Empty data received from Graphite - metric probably doesn\'t exists'
+        else
+          @json_data = JSON.parse(@raw_data)
+          output = {}
+          @json_data.each do |raw|
+            raw['datapoints'].delete_if { |v| v.first.nil? }
+            next if raw['datapoints'].empty?
+            target = raw['target']
+            data = raw['datapoints'].map(&:first)
+            start = raw['datapoints'].first.last
+            dend = raw['datapoints'].last.last
+            step = ((dend - start) / raw['datapoints'].size.to_f).ceil
+            output[target] = { 'target' => target, 'data' => data, 'start' => start, 'end' => dend, 'step' => step }
+          end
+          output
+        end
+      rescue OpenURI::HTTPError
+        unknown 'Failed to connect to graphite server'
+      rescue NoMethodError
+        unknown 'No data for time period and/or target'
+      rescue Errno::ECONNREFUSED
+        unknown 'Connection refused when connecting to graphite server'
+      rescue Errno::ECONNRESET
+        unknown 'Connection reset by peer when connecting to graphite server'
+      rescue EOFError
+        unknown 'End of file error when reading from graphite server'
+      rescue => e
+        unknown "An unknown error occured: #{e.inspect}"
+      end
+    end
+  end
+
+  # type:: :warning or :critical
+  # Return alert if required
+  def check(type)
+    # #YELLOW
+    if config[type] # rubocop:disable GuardClause
+      send(type, "#{@value['target']} has passed #{type} threshold (#{@data.last})") if below?(type) || above?(type)
+    end
+  end
+
+  # Check if value is below defined threshold
+  def below?(type)
+    config[:below] && @data.last < config[type]
+  end
+
+  # Check is value is above defined threshold
+  def above?(type)
+    (!config[:below]) && (@data.last > config[type]) && (!decreased?)
+  end
+
+  # Check if values have decreased within interval if given
+  def decreased?
+    if config[:reset_on_decrease]
+      slice = @data.slice(@data.size - config[:reset_on_decrease], @data.size)
+      val = slice.shift until slice.empty? || val.to_f > slice.first
+      !slice.empty?
+    else
+      false
+    end
+  end
+
+  # Returns formatted target with hostname replacing any $ characters
+  def formatted_target
+    if config[:target].include?('$')
+      require 'socket'
+      @formatted = Socket.gethostbyname(Socket.gethostname).first.gsub('.', config[:hostname_sub] || '_')
+      config[:target].gsub('$', @formatted)
+    else
+      URI.escape config[:target]
+    end
+  end
+end

data/bin/check-graphite-replication.rb

@@ -0,0 +1,227 @@
+#! /usr/bin/env ruby
+#
+#   check-replication
+#
+# DESCRIPTION:
+#   Check to ensure data gets posted and is retrievable by graphite.
+#   We post to each server in config[:relays] then sleep config[:sleep]
+#   seconds then check each of config[:graphites] to see if the data made it
+#   to each one. OK if all servers have the data we expected, WARN if
+#   config[:warning] or fewer have it. CRITICAL if config[:critical]
+#   or fewer have it. config[:check_id] allows you to have many of these
+#   checks running in different places without any conflicts. Customize it
+#   if you are going to run this check from multiple servers. Otherwise
+#   it defaults to default. (can be a descriptive string, used as a graphite key)
+#
+#   This check is most useful when you have a cluster of carbon-relays configured
+#   with REPLICATION_FACTOR > 1 and more than one graphite server those
+#   carbon-relays are configured to post to. This check ensures that replication
+#   is actually happening in a timely manner.
+
+#   How it works: We generate a large random number for each of these servers
+#   Then we post that number to each server via a key in the form of:
+#   checks.graphite.check_id.replication.your_graphite_server.ip It's safe
+#   to throw this data away quickly. A day retention ought to be more
+#   than enough for anybody.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: rest-client
+#   gem: json
+#   gem: ipaddress
+#   gem: resolv
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   AJ Bourg <aj@ajbourg.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'timeout'
+require 'socket'
+require 'rest-client'
+require 'json'
+require 'resolv'
+require 'ipaddress'
+
+class CheckGraphiteReplication < Sensu::Plugin::Check::CLI
+  option :relays,
+         short: '-r RELAYS',
+         long: '--relays RELAYS',
+         description: 'Comma separated list of carbon relay servers to post to.',
+         required: true
+  option :servers,
+         short: '-g SERVERS',
+         long: '--graphite SERVERS',
+         description: 'Comma separated list of all graphite servers to check.',
+         required: true
+  option :sleep,
+         short: '-s SECONDS',
+         long: '--sleep SECONDS',
+         description: 'Time to sleep between submitting and checking for value.',
+         default: 30,
+         proc: proc(&:to_i)
+  option :timeout,
+         short: '-t TIMEOUT',
+         long: '--timeout TIMEOUT',
+         description: 'Timeout limit for posting to the relay.',
+         default: 5,
+         proc: proc(&:to_i)
+  option :port,
+         short: '-p PORT',
+         long: '--port PORT',
+         description: 'Port to post to carbon-relay on.',
+         default: 2003,
+         proc: proc(&:to_i)
+  option :critical,
+         short: '-c COUNT',
+         long: '--critical COUNT',
+         description: 'Number of servers missing our test data to be critical.',
+         default: 2,
+         proc: proc(&:to_i)
+  option :warning,
+         short: '-w COUNT',
+         long: '--warning COUNT',
+         description: 'Number of servers missing our test data to be warning.',
+         default: 1,
+         proc: proc(&:to_i)
+  option :check_id,
+         short: '-i ID',
+         long: '--check-id ID',
+         description: 'Check ID to identify this check.',
+         default: 'default'
+  option :verbose,
+         short: '-v',
+         long: '--verbose',
+         description: 'Verbose.',
+         default: false,
+         boolean: true
+
+  def run
+    messages = []
+    servers = config[:servers].split(',')
+    relay_ips = find_relay_ips(config[:relays].split(','))
+
+    check_id = graphite_key(config[:check_id])
+
+    relay_ips.each do |server_name, ips|
+      ips.each do |ip|
+        messages << post_message(server_name, ip, check_id)
+      end
+    end
+
+    puts "Sleeping for #{config[:sleep]}." if config[:verbose]
+    sleep(config[:sleep])
+
+    fail_count = 0
+    # on every server, check to see if all our data replicated
+    servers.each do |server|
+      messages.each_with_index do |c|
+        unless check_for_message(server, c['key'], c['value'])
+          puts "#{c['relay']} (#{c['ip']}) didn't post to #{server}"
+          fail_count += 1
+        end
+      end
+    end
+
+    if fail_count >= config[:critical]
+      critical "Missing data points. #{fail_count} lookups failed."
+    elsif fail_count >= config[:warning]
+      warning "Missing data points. #{fail_count} lookups failed."
+    end
+
+    success_count = (messages.length * servers.length) - fail_count
+    ok "#{fail_count} failed checks. #{success_count} successful checks."
+  end
+
+  def find_relay_ips(relays)
+    # we may have gotten an IPAddress or a DNS hostname or a mix, so let's try
+
+    relay_ips = {}
+
+    time_out('resolving dns') do
+      relays.each do |r|
+        if IPAddress.valid? r
+          relay_ips[r] = [r]
+        else
+          relay_ips[r] = Resolv.getaddresses(r)
+        end
+      end
+    end
+
+    relay_ips
+  end
+
+  def post_message(server_name, ip, check_id)
+    server_key = graphite_key(server_name)
+
+    number = rand(10_000)
+    time = Time.now.to_i
+
+    ip_key = graphite_key(ip)
+    key = "checks.graphite.#{check_id}.replication.#{server_key}.#{ip_key}"
+
+    time_out("posting data to #{ip}") do
+      t = TCPSocket.new(ip, config[:port])
+      t.puts("#{key} #{number} #{time}")
+      t.close
+    end
+
+    if config[:verbose]
+      puts "Posted #{key} to #{server_name} with #{number} on IP #{ip}."
+    end
+
+    { 'relay' => server_name, 'ip' => ip, 'key' => key, 'value' => number }
+  end
+
+  # checks to see if a value landed on a graphite server
+  def check_for_message(server, key, value)
+    url = "http://#{server}/render?format=json&target=#{key}&from=-10minutes"
+
+    puts "Checking URL #{url}" if config[:verbose]
+    graphite_data = nil
+
+    begin
+      time_out("querying graphite api on #{server}") do
+        graphite_data = RestClient.get url
+        graphite_data = JSON.parse(graphite_data)
+      end
+    rescue RestClient::Exception, JSON::ParserError => e
+      critical "Unexpected error getting data from #{server}: #{e}"
+    end
+
+    success = false
+
+    # we get all the data points for the last 10 minutes, so see if our value
+    # appeared in any of them
+    graphite_data[0]['datapoints'].each do |v|
+      success = true if v[0] == value
+    end
+
+    success
+  end
+
+  def graphite_key(key)
+    key.gsub(',', '_').gsub(' ', '_').gsub('.', '_').gsub('-', '_')
+  end
+
+  def time_out(activity, &block)
+    Timeout.timeout(config[:timeout]) do
+      yield block
+    end
+  rescue Timeout::Error
+    critical "Timed out while #{activity}"
+  end
+end