sensu-plugins-graphite-boutetnico 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd8d8fbe966a0e73b730fa0961d3423480e373ba
+  data.tar.gz: 5a1422843684c036eae71271d75ef05cfc12f7eb
+SHA512:
+  metadata.gz: d74a7d26e63630e9ed672326f00fc78a51a80ac2ea93ec79b111f676507d4df277988400aa36e472be4e383087c2e9524fd902d51dce4bf79225eed1a81288ad
+  data.tar.gz: 5daef99682f10d636733961318dea35485444a6e6b960157bed488ddce1f084f3e0b279f0fb8d8dfe674759ac4e6b585ef23aedc3ad41c321eaad1050c1dbf29

data/CHANGELOG.md

@@ -0,0 +1 @@
+Can be found at [https://github.com/boutetnico/sensu-plugins-graphite/releases](https://github.com/boutetnico/sensu-plugins-graphite/releases).

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,126 @@
+## Sensu-Plugins-graphite
+
+[![Gem Version](https://badge.fury.io/rb/sensu-plugins-graphite-boutetnico.svg)](https://badge.fury.io/rb/sensu-plugins-graphite-boutetnico.svg)
+[![Sensu Bonsai Asset](https://img.shields.io/badge/Bonsai-Download%20Me-brightgreen.svg?colorB=89C967&logo=sensu)](https://bonsai.sensu.io/assets/boutetnico/sensu-plugins-graphite)
+
+## This is an unofficial fork
+
+This fork is automatically tested, built and published to [RubyGems](https://rubygems.org/gems/sensu-plugins-graphite-boutetnico/) and [Bonsai](https://bonsai.sensu.io/assets/boutetnico/sensu-plugins-graphite).
+
+## Files
+ * bin/check-graphite-data
+ * bin/check-graphite-replication
+ * bin/check-graphite-stats
+ * bin/check-graphite
+ * bin/extension-graphite
+ * bin/handler-graphite-event
+ * bin/handler-graphite-notify
+ * bin/handler-graphite-status
+ * bin/handler-graphite-occurrences
+ * 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-occurrences
+```
+{
+ "graphite": {
+    "server":"graphite.example.com",
+    "port":"2003"
+ }
+}
+```
+
+### handler-graphite-notify
+```
+{
+ "graphite_notify": {
+    "host":"graphite.example.com",
+    "port":"2003",
+    "prefix":"sensu.events"
+ }
+}
+```
+
+### handler-graphite-status
+```
+{
+ "graphite_status": {
+    "host":"graphite.example.com",
+    "port":"2003",
+    "prefix":"sensu.events"
+ }
+}
+```
+
+## Full Configuration Example
++**Note that TCP Handler is preferred**
+```
+{
+  "graphite_event": {
+    "server_uri": "https://graphite.example.com:443/events/",
+    "tags": [
+      "custom_tag_a",
+      "custom_tag_b"
+    ]
+  },
+  "handlers":
+  {
+    "default": {
+      "type": "set",
+      "handlers": [
+        "graphite_event"
+      ]
+    },
+    "graphite_tcp": {
+      "type": "tcp",
+      "socket": {
+        "host":"graphite.example.com",
+        "port":2003
+      },
+      "mutator": "only_check_output"
+    },
+    "graphite_event": {
+      "type": "pipe",
+      "filters": [
+        "custom_filter_a",
+        "custom_filter_b"
+      ],
+      "command": "handler-graphite-event.rb"
+    }
+  },
+  "checks": {
+    "metrics_uptime": {
+      "standalone": true,
+      "type": "metric",
+      "handlers": [
+        "graphite_tcp"
+      ],
+      "interval": 60,
+      "command": "metrics-uptime.rb --scheme sensu.host.$(hostname).uptime",
+      "subscribers": [
+        "core"
+      ]
+    }
+  }
+}
+```
+
+## Installation
+
+[Installation and Setup](http://sensu-plugins.io/docs/installation_instructions.html)
+
+## Notes

data/bin/check-graphite-data.rb

@@ -0,0 +1,115 @@
+#! /usr/bin/env ruby
+#
+#   check-data
+#
+# DESCRIPTION:
+#   This plugin checks values within graphite
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# 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'
+
+require 'sensu-plugins-graphite/graphite_proxy/options'
+require 'sensu-plugins-graphite/graphite_proxy/proxy'
+
+class CheckGraphiteData < Sensu::Plugin::Check::CLI
+  include SensuPluginsGraphite::GraphiteProxy::Options
+
+  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 :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)
+
+  # Run checks
+  def run
+    if config[:help]
+      puts opt_parser if config[:help]
+      exit
+    end
+
+    proxy = SensuPluginsGraphite::GraphiteProxy::Proxy.new(config)
+    begin
+      results = proxy.retrieve_data!
+      results.each_pair do |_key, value|
+        @value = value
+        @data = value['data']
+        check_age || check(:critical) || check(:warning)
+      end
+
+      ok("#{name} value OK")
+    rescue SensuPluginsGraphite::GraphiteProxy::ProxyError => e
+      unknown e.message
+    end
+  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
+    if (Time.now.to_i - @value['end']) > config[:allowed_graphite_age]
+      unknown "Graphite data age is past allowed threshold (#{config[:allowed_graphite_age]} seconds)"
+    end
+  end
+
+  # type:: :warning or :critical
+  # Return alert if required
+  def check(type)
+    if config[type]
+      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
+end

data/bin/check-graphite-hosts.rb

@@ -0,0 +1,97 @@
+#! /usr/bin/env ruby
+#
+#   check-graphite-hosts
+#
+# DESCRIPTION:
+#   This plugin checks the number of hosts within Graphite that are sending
+#   data, and alerts if it is below a given threshold
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# 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'
+
+require 'sensu-plugins-graphite/graphite_proxy/options'
+require 'sensu-plugins-graphite/graphite_proxy/proxy'
+
+class CheckGraphiteHosts < Sensu::Plugin::Check::CLI
+  include SensuPluginsGraphite::GraphiteProxy::Options
+
+  # Run checks
+  def run
+    if config[:help]
+      puts opt_parser if config[:help]
+      exit
+    end
+
+    proxy = SensuPluginsGraphite::GraphiteProxy::Proxy.new(config)
+    begin
+      results = proxy.retrieve_data!
+
+      check(:critical, results) || check(:warning, results)
+      ok("#{name} value (#{hosts_with_data(results)}) OK")
+    rescue SensuPluginsGraphite::GraphiteProxy::ProxyError => e
+      unknown e.message
+    end
+  end
+
+  # name used in responses
+  def name
+    base = config[:name]
+    @formatted ? "#{base} (#{@formatted})" : base
+  end
+
+  # return the number of hosts with data in the given set of results
+  def hosts_with_data(resultset)
+    resultset.count { |_host, values| !values['data'].empty? }
+  end
+
+  # type:: :warning or :critical
+  # Return alert if required
+  def check(type, results)
+    # #YELLOW
+    num_hosts = hosts_with_data(results)
+    return unless config[type] && threshold_crossed?(type, num_hosts)
+
+    msg = hosts_threshold_message(config[:target], num_hosts, type)
+    send(type, msg)
+  end
+
+  def threshold_crossed?(type, num_hosts)
+    below?(type, num_hosts) || above?(type, num_hosts)
+  end
+
+  def hosts_threshold_message(target, hosts, type)
+    "Number of hosts sending #{target} (#{hosts}) has passed #{type} threshold (#{config[type]})"
+  end
+
+  # Check if value is below defined threshold
+  def below?(type, val)
+    config[:below] && val < config[type]
+  end
+
+  # Check is value is above defined threshold
+  def above?(type, val)
+    !config[:below] && (val > config[type])
+  end
+end

data/bin/check-graphite-replication.rb

@@ -0,0 +1,234 @@
+#! /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: ipaddress
+#
+# USAGE:
+#   Basic check, expect metrics to land on these graphite servers
+#   check-graphite-replication.rb -r relay1 -g graphite1,graphite2
+#
+#   Make sure all 4 graphite instances get the metric
+#   check-graphite-replication.rb -r relay1 -g graphite1,graphite2,graphite3 graphite4 -c 1
+#
+#   Test multiple relay servers
+#   check-graphite-replication.rb -r relay1,relay2 -g graphite1,graphite2
+#
+#   Test from multiple locations (no conflicts)
+#   check-graphite-replication.rb -r relay1,relay2 -g graphite1,graphite2 -i check_1
+#   check-graphite-replication.rb -r relay1,relay2 -g graphite1,graphite2 -i check_2
+#
+# 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 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|
+        relay_ips[r] = if IPAddress.valid? r
+                         [r]
+                       else
+                         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.tr(',', '_').tr(' ', '_').tr('.', '_').tr('-', '_')
+  end
+
+  def time_out(activity, &block)
+    Timeout.timeout(config[:timeout]) do
+      yield block
+    end
+  rescue Timeout::Error
+    critical "Timed out while #{activity}"
+  end
+end