riemann-tools-dgvz 0.2.2.1

data/bin/riemann-munin

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+# Gathers munin statistics and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Munin
+  include Riemann::Tools
+  require 'munin-ruby'
+
+  def initialize
+    @munin = ::Munin::Node.new
+  end
+
+  def tick
+    services = opts[:services] || @munin.list
+    services.each do |service|
+      @munin.fetch(service).each do |service, parts|
+        parts.each do |part, metric|
+          report(
+            :service => "#{service} #{part}",
+            :metric => metric.to_f,
+            :state => 'ok',
+            :tags => ['munin']
+          )
+        end
+      end
+    end
+  end
+  
+  opt :munin_host, "Munin hostname", :default => 'localhost'
+  opt :munin_port, "Munin port", :default => 4949
+  opt :services, "Munin services to translate (if not specified, all services are relayed)", :type => :strings
+end
+  
+Riemann::Tools::Munin.run

data/bin/riemann-net

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+# Gathers network interface statistics and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Net
+  include Riemann::Tools
+  
+  opt :interfaces, "Interfaces to monitor", :type => :strings, :default => nil
+  opt :ignore_interfaces, "Interfaces to ignore", :type => :strings, :default =>['lo']
+
+  def initialize
+    @old_state = nil
+    @interfaces = opts[:interfaces].map(&:dup) if opts[:interfaces]
+    @ignore_interfaces = opts[:ignore_interfaces].map(&:dup)
+  end
+
+  def state
+    f = File.read('/proc/net/dev')
+    state = f.split("\n").inject({}) do |s, line|
+      if line =~ /\s*(\w+?):\s*([\s\d]+)\s*/
+        iface = $1
+
+        ['rx bytes',
+        'rx packets',
+        'rx errs',
+        'rx drop',
+        'rx fifo',
+        'rx frame',
+        'rx compressed',
+        'rx multicast',
+        'tx bytes',
+        'tx packets',
+        'tx errs',
+        'tx drops',
+        'tx fifo',
+        'tx colls',
+        'tx carrier',
+        'tx compressed'].map do |service|
+          "#{iface} #{service}"
+        end.zip(
+          $2.split(/\s+/).map { |str| str.to_i }
+        ).each do |service, value|
+          s[service] = value
+        end
+      end
+      
+      s
+    end
+
+    # Filter interfaces
+    if is = @interfaces
+      state = state.select do |service, value|
+        is.include? service.split(' ').first
+      end
+    end
+
+    state = state.reject do |service, value|
+      @ignore_interfaces.include? service.split(' ').first
+    end
+
+    state
+  end
+  
+  def tick
+    state = self.state
+
+    if @old_state
+      state.each do |service, metric|
+        delta = metric - @old_state[service]
+        svc_state = case service
+          when /drop$/
+            if metric > 0
+              'warning'
+            else
+              'ok'
+            end
+          when /errs$/
+            if metric > 0
+              'warning'
+            else
+              'ok'
+            end
+          else
+            'ok'
+          end
+
+        report(
+          :service => service.dup,
+          :metric => (delta.to_f / opts[:interval]),
+          :state => svc_state
+        )
+      end
+    end
+
+    @old_state = state
+  end
+end
+  
+Riemann::Tools::Net.run

data/bin/riemann-nginx-status

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+# Gathers nginx status stub statistics and submits them to Riemann.
+# See http://wiki.nginx.org/HttpStubStatusModule for configuring Nginx appropriately
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::NginxStatus
+  include Riemann::Tools
+  require 'net/http'
+  require 'uri'
+
+  opt :uri, "Nginx Stub Status URI", :default => 'http://localhost:8080/nginx_status'
+  opt :checks, "Which metrics to report.", :type => :strings, :default => %w{active accepted handled requests reading writing waiting}
+  opt :active_warning, "Active connections warning threshold", :default => 0
+  opt :active_critical, "Active connections critical threshold", :default => 0
+  opt :reading_warning, "Reading connections warning threshold", :default => 0
+  opt :reading_critical, "Reading connections critical threshold", :default => 0
+  opt :writing_warning, "Writing connections warning threshold", :default => 0
+  opt :writing_critical, "Writing connections critical threshold", :default => 0
+  opt :waiting_warning, "Waiting connections warning threshold", :default => 0
+  opt :waiting_critical, "Waiting connections critical threshold", :default => 0
+
+  def initialize
+    @uri = URI.parse(opts[:uri])
+
+    # sample response:
+    #
+    # Active connections: 1 
+    # server accepts handled requests
+    #  39 39 39 
+    # Reading: 0 Writing: 1 Waiting: 0 
+    @keys = %w{active accepted handled requests reading writing waiting}
+    @re = /Active connections: (\d+) \n.+\n (\d+) (\d+) (\d+) \nReading: (\d+) Writing: (\d+) Waiting: (\d+)/m
+  end
+
+  def state(key, value)
+    if opts.has_key? "#{key}_critical".to_sym
+      critical_threshold = opts["#{key}_critical".to_sym]
+      return 'critical' if critical_threshold > 0 and value >= critical_threshold
+    end
+
+    if opts.has_key? "#{key}_warning".to_sym
+      warning_threshold = opts["#{key}_warning".to_sym]
+      return 'warning' if warning_threshold > 0 and value >= warning_threshold
+    end
+
+    return 'ok'
+  end
+
+  def tick
+    response = nil
+    begin
+      response = Net::HTTP.get(@uri)
+    rescue => e
+      report(
+        :service => "nginx health",
+        :state => "critical",
+        :description => "Connection error: #{e.class} - #{e.message}"
+      )
+    end
+
+    return if response.nil?
+
+    report(
+      :service => "nginx health",
+      :state => "ok",
+      :description => "Nginx status connection ok"
+    )
+
+    values = @re.match(response).to_a[1,7].map { |v| v.to_i }
+
+    @keys.zip(values).each do |key, value|
+      report({
+        :service => "nginx #{key}",
+        :metric  => value,
+        :state   => state(key, value),
+        :tags    => ['nginx']
+      })
+    end
+  end
+end
+
+Riemann::Tools::NginxStatus.run

data/bin/riemann-proc

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+# Reports running process count to riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Proc
+  include Riemann::Tools
+
+  opt :proc_regex, "regular expression that matches the process to be monitored", type: :string
+  opt :proc_min_critical, "running process count minimum", :default => 1
+  opt :proc_max_critical, "running process count maximum", :default => 1
+
+  def initialize
+    @limits = { :critical => { :min => opts[:proc_min_critical], :max => opts[:proc_max_critical] } }
+
+    abort "FATAL: specify a process regular expression, see --help for usage" unless opts[:proc_regex]
+
+    ostype = `uname -s`.chomp.downcase
+    puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == "linux"
+    @check = method :linux_proc
+  end
+
+  def alert(service, state, metric, description)
+    report(
+      :service => service.to_s,
+      :state => state.to_s,
+      :metric => metric.to_f,
+      :description => description
+    )
+  end
+
+  def linux_proc
+    process = opts[:proc_regex]
+    running = Integer(`ps axo args | grep '#{process}' | grep -v grep | grep -v riemann-proc | wc -l`)
+    if running > @limits[:critical][:max] or running < @limits[:critical][:min]
+      alert "proc #{process}", :critical, running, "process #{process} is running #{running} instances"
+    else
+      alert "proc #{process}", :ok, running, "process #{process} is running #{running} instances"
+    end
+  end
+
+  def tick
+    @check.call
+  end
+end
+
+Riemann::Tools::Proc.run

data/bin/riemann-rabbitmq

@@ -0,0 +1,99 @@
+#!/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', default: 15672
+  opt :monitor_host, 'RabbitMQ monitoring host', default: "localhost"
+
+  def monitor_url
+    "http://#{options[:monitor_user]}:#{options[:monitor_pass]}@#{options[:monitor_host]}:#{options[:monitor_port]}/api/overview"
+  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
+      rescue => e
+        report(:host => event_host,
+          :service => "rabbitmq monitoring",
+          :state => "critical",
+          :description => "HTTP connection error: #{e.class} - #{e.message}"
+        )
+      end
+      response
+  end
+
+  def tick
+    uri = URI(monitor_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
+end
+Riemann::Tools::Rabbitmq.run

data/bin/riemann-resmon

@@ -0,0 +1,103 @@
+#!/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