riemann-tools 0.2.7 → 0.2.8

data/bin/riemann-rabbitmq

@@ -1,267 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Rabbitmq
-  include Riemann::Tools
-
-  require 'faraday'
-  require 'json'
-  require 'uri'
-
-
-  opt :read_timeout, 'Faraday read timeout', type: :int, default: 2
-  opt :open_timeout, 'Faraday open timeout', type: :int, default: 1
-
-  opt :monitor_user, 'RabbitMQ monitoring user', type: :string
-  opt :monitor_pass, 'RabbitMQ monitoring user password', type: :string
-  opt :monitor_port, 'RabbitMQ monitoring port', type: :int, default: 15672
-  opt :monitor_host, 'RabbitMQ monitoring host', type: :string, default: "localhost"
-  opt :monitor_use_tls, 'RabbitMQ use tls', type: :bool, default: false
-
-  opt :max_queue_size, "max number of items in a queue that is acceptable", type: :int, default: 1_000_000
-  opt :ignore_max_size_queues, "A regular expression to match queues that shouldn't be size-checked", type: :string
-
-  opt :node, "Specify a node to monitor", type: :strings
-
-  def base_url
-    protocol = "http"
-    if (options[:monitor_use_tls]) && (options[:monitor_use_tls]==true)
-      protocol = "https"
-    end
-    "#{protocol}://#{options[:monitor_user]}:#{options[:monitor_pass]}@#{options[:monitor_host]}:#{options[:monitor_port]}/api"
-  end
-
-  def overview_url
-    "#{base_url}/overview"
-  end
-
-  def node_url(n)
-    "#{base_url}/nodes/#{n}"
-  end
-
-  def queues_url
-    "#{base_url}/queues"
-  end
-
-  def event_host
-    if options[:event_host]
-      return options[:event_host]
-    else
-      return options[:monitor_host]
-    end
-  end
-
-  def safe_get(uri, event_host)
-      # Handle connection timeouts
-      response = nil
-      begin
-        connection = Faraday.new(uri)
-        response = connection.get do |req|
-          req.options[:timeout] = options[:read_timeout]
-          req.options[:open_timeout] = options[:open_timeout]
-        end
-        report(:host => event_host,
-          :service => "rabbitmq monitoring",
-          :state   => 'ok',
-          :description => "Monitoring operational"
-        )
-      rescue => e
-        report(:host => event_host,
-          :service => "rabbitmq monitoring",
-          :state => "critical",
-          :description => "HTTP connection error: #{e.class} - #{e.message}"
-        )
-      end
-      response
-  end
-
-  def check_queues
-    response = safe_get(queues_url, event_host)
-    max_size_check_filter = if options[:ignore_max_size_queues]
-      Regexp.new(options[:ignore_max_size_queues])
-    else
-      nil
-    end
-
-    return if response.nil?
-
-    json = JSON.parse(response.body)
-
-    if response.status != 200
-        report(:host => event_host,
-          :service => "rabbitmq.queue",
-          :state => "critical",
-          :description => "HTTP connection error to /api/queues: #{response.status} - #{response.body}"
-        )
-    else
-      report(:host => event_host,
-        :service => "rabbitmq.queue",
-        :state => "ok",
-        :description => "HTTP connection ok"
-      )
-
-      json = JSON.parse(response.body)
-
-      json.each do |queue|
-        svc = "rabbitmq.queue.#{queue['vhost']}.#{queue['name']}"
-        errs = []
-
-        if queue['messages_ready']!=nil and queue['messages_ready'] > 0 and queue['consumers'] == 0
-          errs << "Queue has jobs but no consumers"
-        end
-
-        if (max_size_check_filter.nil? or queue['name'] !~ max_size_check_filter) and queue['messages_ready']!=nil and queue['messages_ready'] > options[:max_queue_size]
-          errs << "Queue has #{queue['messages_ready']} jobs"
-        end
-
-        if errs.empty?
-          report(:host    => event_host,
-                 :service => svc,
-                 :state   => "ok",
-                 :description => "Queue is looking good"
-          )
-        else
-          report(:host    => event_host,
-                 :service => svc,
-                 :state   => "critical",
-                 :description => errs.join("; ")
-          )
-        end
-
-        stats = (queue['message_stats'] || {}).merge(
-                  'messages'                        => queue['messages'],
-                  'messages_details'                => queue['messages_details'],
-                  'messages_ready'                  => queue['messages_ready'],
-                  'messages_ready_details'          => queue['messages_ready_details'],
-                  'messages_unacknowledged'         => queue['messages_unacknowledged'],
-                  'messages_unacknowledged_details' => queue['messages_unacknowledged_details'],
-                  'consumers'                       => queue['consumers'],
-                  'memory'                          => queue['memory'],
-                )
-
-        stats.each_pair do |k,v|
-          service = "#{svc}.#{k}"
-          if k =~ /details$/ and v!=nil
-            metric = v['rate']
-          else
-            metric = v
-          end
-
-          # TODO: Set state via thresholds which can be configured
-
-          report(:host => event_host,
-                 :service => service,
-                 :metric => metric,
-                 :description => "RabbitMQ monitor"
-          )
-        end
-      end
-    end
-  end
-
-  def check_overview
-    uri = URI(overview_url)
-    response = safe_get(uri, event_host)
-
-    return if response.nil?
-
-    json = JSON.parse(response.body)
-
-    if response.status != 200
-        report(:host => event_host,
-          :service => "rabbitmq",
-          :state => "critical",
-          :description => "HTTP connection error: #{response.status} - #{response.body}"
-        )
-    else
-      report(:host => event_host,
-        :service => "rabbitmq monitoring",
-        :state => "ok",
-        :description => "HTTP connection ok"
-      )
-
-      %w( message_stats queue_totals object_totals ).each do |stat|
-        # NOTE / BUG ?
-        # Brand new servers can have blank message stats. Is this ok?
-        # I can't decide.
-        next if json[stat].empty?
-        json[stat].each_pair do |k,v|
-          service = "rabbitmq.#{stat}.#{k}"
-          if k =~ /details$/
-            metric = v['rate']
-          else
-            metric = v
-          end
-
-          # TODO: Set state via thresholds which can be configured
-
-          report(:host => event_host,
-                 :service => service,
-                 :metric => metric,
-                 :description => "RabbitMQ monitor"
-                )
-        end
-      end
-    end
-  end
-
-  def check_node
-    opts[:node].each do |n|
-      uri = URI(node_url(n))
-      response = safe_get(uri, event_host)
-
-      return if response.nil?
-
-      if response.status != 200
-        if response.status == 404
-          report(:host => event_host,
-            :service => "rabbitmq.node.#{n}",
-            :state => "critical",
-            :description => "Node was not found in the cluster"
-          )
-        else
-          report(:host => event_host,
-            :service => "rabbitmq.node.#{n}",
-            :state => "critical",
-            :description => "HTTP error: #{response.status} - #{response.body}"
-          )
-        end
-        return
-      end
-
-      json = JSON.parse(response.body)
-
-      if json['mem_alarm']
-        report(:host => event_host,
-          :service => "rabbitmq.node.#{n}",
-          :state     => "critical",
-          :description => "Memory alarm has triggered; job submission throttled"
-        )
-        return
-      end
-
-      if json['disk_free_alarm']
-        report(:host => event_host,
-          :service => "rabbitmq.node.#{n}",
-          :state     => "critical",
-          :description => "Disk free alarm has triggered; job submission throttled"
-        )
-        return
-      end
-
-      report(:host => event_host,
-        :service => "rabbitmq.node.#{n}",
-        :state   => "ok",
-        :description => "Node looks OK to me"
-      )
-    end
-  end
-
-  def tick
-    check_overview
-    check_node if opts[:node]
-    check_queues
-  end
-end
-Riemann::Tools::Rabbitmq.run

data/bin/riemann-resmon

@@ -1,103 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Resmon
-  include Riemann::Tools
-  require 'nokogiri'
-  require 'faraday'
-
-  opt :resmon_hostfile, 'File with hostnames running Resmon (one URI per line)', type: :string
-  opt :read_timeout, 'Faraday read timeout', type: :int, default: 2
-  opt :open_timeout, 'Faraday open timeout', type: :int, default: 1
-  opt :fqdn, 'Use FQDN for event host'
-
-
-  def initialize
-    @hosts = File.read(options[:resmon_hostfile]).split("\n")
-    super
-  end
-
-
-  # Work out the hostname to submit with the event
-  def get_event_host(host)
-    unless options[:fqdn]
-      return host.split('.')[0]
-    end
-    return host
-  end
-
-  # Handles HTTP connections and GET requests safely
-  def safe_get(uri, event_host)
-      # Handle connection timeouts
-      response = nil
-      begin
-        connection = Faraday.new(uri)
-        response = connection.get do |req|
-          req.options[:timeout] = options[:read_timeout]
-          req.options[:open_timeout] = options[:open_timeout]
-        end
-      rescue => e
-        report(:host => event_host,
-          :service => "resmon",
-          :state => "critical",
-          :description => "HTTP connection error: #{e.class} - #{e.message}"
-        )
-      end
-      response
-  end
-
-  def tick
-    @hosts.each do |host|
-
-      uri = URI(host)
-      event_host = get_event_host(uri.host)
-
-      response = safe_get(uri, event_host)
-      next if response.nil?
-
-      # Handle non-200 responses
-      if response.status != 200
-        report(:host => event_host,
-          :service => "resmon",
-          :state => "critical",
-          :description => "HTTP connection error: #{response.status} - #{response.body}"
-        )
-        next
-      else
-        report(:host => event_host,
-          :service => "resmon",
-          :state => "ok",
-          :description => "Resmon connection ok"
-        )
-        doc = Nokogiri::XML(response.body)
-      end
-
-      doc.xpath('//ResmonResults/ResmonResult').each do |result|
-        timestamp = result.xpath('last_update').first.text
-        result.xpath('metric').each do |metric|
-          hash = {
-            host: event_host,
-            service: "#{result.attributes['module'].value}`#{result.attributes['service'].value}`#{metric.attributes['name'].value}",
-            time: timestamp.to_i
-          }
-
-          case metric.attributes['type'].value
-            when /[iIlL]/
-              hash[:metric] = metric.text.to_i
-            when 'n'
-              hash[:metric] = metric.text.to_f
-            when 's'
-              hash[:description] = metric.text
-            when '0'
-              raise 'dunno what 0 is yet'
-          end
-
-          report(hash)
-        end
-      end
-    end
-  end
-end
-
-Riemann::Tools::Resmon.run

data/bin/riemann-riak

@@ -1,329 +0,0 @@
-#!/usr/bin/env ruby
-
-# Forwards information on a Riak node to Riemann.
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-require 'net/http'
-require 'net/https'
-require 'yajl/json_gem'
-
-class Riemann::Tools::Riak
-  include Riemann::Tools
-
-  opt :riak_host, "Riak host for stats <IP> or SSL http(s)://<IP>", :default => Socket.gethostname
-  opt :data_dir, "Riak data directory", :default => '/var/lib/riak'
-  opt :stats_port, "Riak HTTP port for stats", :default => 8098
-  opt :stats_path, "Riak HTTP stats path", :default => '/stats'
-  opt :node_name, "Riak erlang node name", :default => "riak@#{Socket.gethostname}"
-  opt :cookie, "Riak cookie to use", :default => "riak"
-
-  opt :get_50_warning, "FSM 50% get time warning threshold (ms)", :default => 1000
-  opt :put_50_warning, "FSM 50% put time warning threshold (ms)", :default => 1000
-  opt :get_95_warning, "FSM 95% get time warning threshold (ms)", :default => 2000
-  opt :put_95_warning, "FSM 95% put time warning threshold (ms)", :default => 2000
-  opt :get_99_warning, "FSM 99% get time warning threshold (ms)", :default => 10000
-  opt :put_99_warning, "FSM 99% put time warning threshold (ms)", :default => 10000
-
-  def initialize
-    detect_features
-
-    @httpstatus = true
-    # What's going on here? --aphyr
-    if
-      begin
-        uri = URI.parse(opts[:riak_host])
-      if uri.host == nil
-      uri.host = opts[:riak_host]
-      end
-        http = Net::HTTP.new(uri.host, opts[:stats_port])
-        http.use_ssl = uri.scheme == 'https'
-          if http.use_ssl?
-              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          end
-        http.start do |http|
-        http.get opts[:stats_path]
-      end
-      rescue => e
-        @httpstatus = false
-      end
-    end
-
-    # we're going to override the emulator setting to allow users to
-    # dynamically input the cookie
-    # this is done only once - hopefully it doesn't get overridden.
-    ENV['ERL_AFLAGS'] = "-setcookie #{opts[:cookie]}"
-  end
-
-  # Identifies whether escript and riak-admin are installed
-  def detect_features
-    @escript = true # Whether escript is present on this machine
-    @riakadmin = true # Whether riak-admin is present
-
-    if `which escript` =~ /^\s*$/
-      @escript = false
-    end
-
-    if `which riak-admin` =~ /^\s*$/
-      @riakadmin = false
-    end
-  end
-
-  def check_ring
-    if @escript
-      str = `#{File.expand_path(File.dirname(__FILE__))}/riemann-riak-ring #{opts[:node_name]}`.chomp
-    elsif @riakadmin
-      str = `riak-admin ringready`
-    end
-
-    if str =~ /^TRUE/
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak ring',
-        :state => 'ok',
-        :description => str
-      )
-    else
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak ring',
-        :state => 'warning',
-        :description => str
-      )
-    end
-  end
-
-  def check_keys
-    keys = `#{File.expand_path(File.dirname(__FILE__))}/riemann-riak-keys #{opts[:node_name]}`.chomp
-    if keys =~ /^\d+$/
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak keys',
-        :state => 'ok',
-        :metric => keys.to_i,
-        :description => keys
-      )
-    else
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak keys',
-        :state => 'unknown',
-        :description => keys
-      )
-    end
-  end
-
-  def check_transfers
-    str = if @riakadmin
-      `riak-admin transfers`
-    else
-      nil
-    end
-
-    return if str.nil?
-
-    if str =~ /'#{opts[:node_name]}' waiting to handoff (\d+) partitions/
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak transfers',
-        :state   => 'critical',
-        :metric  => $1.to_i,
-        :description => "waiting to handoff #{$1} partitions"
-      )
-    else
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak transfers',
-        :state   => 'ok',
-        :metric  => 0,
-        :description => "No pending transfers"
-      )
-    end
-  end
-
-  def check_disk
-    gb = `du -Ls #{opts[:data_dir]}`.split(/\s+/).first.to_i / (1024.0**2)
-    report(
-      :host => opts[:riak_host],
-      :service => 'riak disk',
-      :state => 'ok',
-      :metric => gb,
-      :description => "#{gb} GB in #{opts[:data_dir]}"
-    )
-  end
-
-  # Returns the riak stat for the given fsm type and percentile.
-  def fsm_stat(type, property, percentile)
-    "node_#{type}_fsm_#{property}_#{percentile == 50 ? 'median' : percentile}"
-  end
-
-  # Returns the alerts state for the given fsm.
-  def fsm_state(type, percentile, val)
-    limit = opts["#{type}_#{percentile}_warning".to_sym]
-    case val
-    when 0 .. limit
-      'ok'
-    when limit .. limit * 2
-      'warning'
-    else
-      'critical'
-    end
-  end
-
-  # Get current stats via HTTP
-  def stats_http
-    begin
-      uri = URI.parse(opts[:riak_host])
-      if uri.host == nil
-        uri.host = opts[:riak_host]
-      end
-      http = Net::HTTP.new(uri.host, opts[:stats_port])
-      http.use_ssl = uri.scheme == 'https'
-      if http.use_ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      res = http.start do |http|
-        http.get opts[:stats_path]
-      end
-    rescue => e
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak',
-        :state => 'critical',
-        :description => "error fetching #{opts[:riak_host]}:#{opts[:stats_port]} #{e.class}, #{e.message}"
-      )
-      raise
-    end
-
-    if res.code.to_i == 200
-      return JSON.parse(res.body)
-    else
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak',
-        :state => 'critical',
-        :description => "stats returned HTTP #{res.code}:\n\n#{res.body}"
-      )
-      raise "Can't fetch stats via HTTP: #{res.core}:\n\n#{res.body}"
-    end
-  end
-
-  # Get current stats via riak-admin
-  def stats_riak_admin
-    str = `riak-admin status`
-    raise "riak-admin failed" unless $? == 0
-    Hash[str.split(/\n/).map{|i| i.split(/ : /)}]
-  end
-
-  # Get current stats as a hash
-  def stats
-    if @httpstatus
-      stats_http
-    elsif @riakadmin
-      stats_riak_admin
-    else
-      report(
-        :host => opts[:riak_host],
-        :service => 'riak',
-        :state => 'critical',
-        :description => "No mechanism for fetching Riak stats: neither HTTP nor riak-admin available."
-      )
-      raise "No mechanism for fetching Riak stats: neither HTTP nor riak-admin available."
-    end
-  end
-
-  def core_services
-    ['vnode_gets',
-     'vnode_puts',
-     'node_gets',
-     'node_puts',
-     'node_gets_set',
-     'node_puts_set',
-     'read_repairs']
-  end
-
-  def fsm_types
-    [{'get' => 'time'}, {'put' => 'time'},
-     {'get' => 'set_objsize'}]
-  end
-
-  def fsm_percentiles
-    [50, 95, 99]
-  end
-
-  # Reports current stats to Riemann
-  def check_stats
-    begin
-      stats = self.stats
-    rescue => e
-      event = {:state => 'critical',
-               :description => e.message,
-               :host => opts[:riak_host]}
-      # Report errors
-      report(event.merge(:service => 'riak'))
-      core_services.each do |s|
-        report(event.merge(:service => "riak #{s}"))
-      end
-      fsm_types.each do |typespec|
-        typespec.each do |type, prop|
-          fsm_percentiles.each do |percentile|
-            report(event.merge(:service => "riak #{type} #{prop} #{percentile}"))
-          end
-        end
-      end
-      return
-    end
-
-    # Riak itself
-    report(
-      :host => opts[:riak_host],
-      :service => 'riak',
-      :state => 'ok'
-    )
-
-    # Gets/puts/rr
-    core_services.each do |s|
-      report(
-        :host => opts[:riak_host],
-        :service => "riak #{s}",
-        :state => 'ok',
-        :metric => stats[s].to_i/60.0,
-        :description => "#{stats[s].to_i/60.0}/sec"
-      )
-    end
-
-    # FSMs
-    fsm_types.each do |typespec|
-      typespec.each do |type, prop|
-        fsm_percentiles.each do |percentile|
-          val = stats[fsm_stat(type, prop, percentile)].to_i || 0
-          val = 0 if val == 'undefined'
-          val /= 1000.0 if prop == 'time' # Convert us to ms
-          if prop == 'time'
-            state = fsm_state(type,  percentile, val)
-          else
-            state = "ok"
-          end
-          report(
-            :host => opts[:riak_host],
-            :service => "riak #{type} #{prop} #{percentile}",
-            :state => state,
-            :metric => val,
-            :description => "#{val} ms"
-          )
-        end
-      end
-    end
-  end
-
-  def tick
-    # This can utterly destroy a cluster, so we disable
-    # check_keys
-    check_stats
-    check_ring
-    check_disk
-    check_transfers
-  end
-end
-
-Riemann::Tools::Riak.run