riemann-tools.haf 0.1.9

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 munin 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-redis

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# Gathers redis INFO statistics and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Redis
+  include Riemann::Tools
+  require 'redis'
+
+  opt :redis_host, "Redis hostname", :default => 'localhost'
+  opt :redis_port, "Redis port", :default => 6379
+  opt :redis_password, "Redis password", :default => ''
+  opt :redis_url, "Redis URL", :default => ''
+  opt :redis_socket, "Redis socket", :default => ''
+  opt :redis_section, "Redis INFO section", :default => 'default'
+
+  STRING_VALUES = %w{ redis_version redis_git_sha1 redis_mode os
+                      multiplexing_api gcc_version run_id used_memory_human
+                      used_memory_peak_human mem_allocator
+                      rdb_last_bgsave_status aof_last_bgrewrite_status role }
+
+  def initialize
+    options = if opts[:redis_url] != ''
+                { :url => opts[:redis_url] }
+              elsif opts[:redis_socket] != ''
+                { :path => opts[:redis_socket] }
+              else
+                { :host => opts[:redis_host], :port => opts[:redis_port] }
+              end
+    @redis = ::Redis.new(options)
+    @redis.auth(opts[:redis_password]) unless opts[:redis_password] == ''
+    @section = opts[:redis_section]
+  end
+
+  def tick
+    begin
+      @redis.info(@section).each do |property, value|
+        data = {
+          :host    => opts[:redis_host].dup,
+          :service => "redis #{property}",
+          :metric  => value.to_f,
+          :state   => value.to_s,
+          :tags    => ['redis']
+        }
+
+        if STRING_VALUES.include?(property) || property.match(/^db\d+/)
+          if %w{ rdb_last_bgsave_status aof_last_bgrewrite_status }.include?(property)
+            data[:state] = value
+          else
+            data[:description] = value
+          end
+        end
+
+        if property == "run_id"
+          data[:metric] = 0
+        end
+
+        report(data)
+      end
+    rescue ::Redis::CommandError => e
+      if e.message == "ERR operation not permitted"
+        @redis.auth(opts[:redis_password]) unless opts[:redis_password] == ''
+      end
+    end
+
+  end
+
+end
+
+Riemann::Tools::Redis.run

data/bin/riemann-redis-slowlog

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# Gathers Redis SLOWLOG statistics and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::RedisSlowlog
+  include Riemann::Tools
+  require 'redis'
+
+  opt :redis_url,      "Redis URL",                        :default => 'redis://127.0.0.1:6379/'
+  opt :redis_password, "Redis password",                   :default => ''
+  opt :slowlog_len,    "Number of SLOWLOG entries to get", :default => 10
+  opt :slowlog_reset,  "Reset SLOWLOG after querying it",  :default => false
+
+  def initialize
+    @redis = ::Redis.new(url: opts[:redis_url])
+
+    @slowlog_len   = opts[:slowlog_len]
+    @slowlog_reset = opts[:slowlog_reset]
+
+    @redis.auth(opts[:redis_password]) unless opts[:redis_password] == ''
+  end
+
+  def tick
+    @redis.slowlog("GET", @slowlog_len).each do |id, timestamp, us, cmd|
+      data = {
+        :host        => @redis.client.host,
+        :service     => "redis",
+        :time        => timestamp,
+        :metric      => us.to_f,
+        :state       => 'warning',
+        :tags        => ['redis', 'slowlog'],
+        :description => cmd.inspect
+      }
+      report(data)
+    end
+
+    @redis.slowlog("RESET") if @slowlog_reset
+  end
+
+end
+
+Riemann::Tools::RedisSlowlog.run