riemann-tools.haf 0.1.9

data/bin/riemann-fd

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# Reports current file descriptor use to riemann.
+# By default reports the total system fd usage, can also report usage of individual processes
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Health
+  include Riemann::Tools
+
+  opt :fd_sys_warning, "open file descriptor threshold for system", :default => 800
+  opt :fd_sys_critical, "open file descriptor critical threshold for system", :default => 900
+  opt :fd_proc_warning, "open file descriptor threshold for process", :default => 800
+  opt :fd_proc_critical, "open file descriptor critical threshold for process", :default => 900
+  opt :processes, "list of processes to measure fd usage in addition to system total", :type => :ints
+
+  def initialize
+    @limits = {
+      :fd => {:critical => opts[:fd_sys_critical], :warning => opts[:fd_sys_warning]},
+      :process => {:critical => opts[:fd_proc_critical], :warning => opts[:fd_proc_warning]},
+    }
+    ostype = `uname -s`.chomp.downcase
+    puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == "linux"
+    @fd = method :linux_fd
+  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_fd
+    sys_used = Integer(`lsof | wc -l`)
+    if sys_used > @limits[:fd][:critical]
+      alert "fd sys", :critical, sys_used, "system is using #{sys_used} fds"
+    elsif sys_used > @limits[:fd][:warning]
+      alert "fd sys", :warning, sys_used, "system is using #{sys_used} fds"
+    else
+      alert "fd sys", :ok, sys_used, "system is using #{sys_used} fds"
+    end
+
+    unless opts[:processes].nil?
+      opts[:processes].each do |process|
+        used = Integer(`lsof -p #{process} | wc -l`)
+        name, pid = `ps axo comm,pid | grep -w #{process}`.split
+        if used > @limits[:process][:critical]
+          alert "fd #{name} #{process}", :critical, used, "process #{name} #{process} is using #{used} fds"
+        elsif used > @limits[:process][:warning]
+          alert "fd #{name} #{process}", :warning, used, "process #{name} #{process} is using #{used} fds"
+        else
+          alert "fd #{name} #{process}", :ok, used, "process #{name} #{process} is using #{used} fds"
+        end
+      end
+    end
+  end
+
+  def tick
+    @fd.call
+  end
+end
+
+Riemann::Tools::Health.run

data/bin/riemann-freeswitch

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::FreeSWITCH
+  include Riemann::Tools
+
+  def tick
+
+  #determine how many current calls I have according to FreeSWITCH
+  fs_calls = %x[fs_cli -x "show calls count"| grep -Po '^\\d+']
+  
+  #determine how many current channels I have according to FreeSWITCH
+  fs_channels = %x[fs_cli -x "show channels count"| grep -Po '^\\d+']
+
+  #submit them to riemann
+  report(
+     :service => "FreeSWITCH current calls",
+     :metric => fs_calls.to_i,
+     :state => "info"
+       )
+
+  report(
+     :service => "FreeSWITCH current channels",
+     :metric => fs_channels.to_i,
+     :state => "info"
+       )
+  end
+end
+
+Riemann::Tools::FreeSWITCH.run

data/bin/riemann-haproxy

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+# Gathers haproxy CSV statistics and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Haproxy
+  include Riemann::Tools
+  require 'net/http'
+  require 'csv'
+
+  opt :stats_url, "Full url to haproxy stats (eg: https://user:password@host.com:9999/stats)", :required => true, :type => :string
+
+  def initialize
+    @uri = URI(opts[:stats_url]+';csv')
+  end
+
+  def tick
+    csv = CSV.parse(get_csv.body.split("# ")[1], { :headers => true })
+    csv.each do |row|
+      row = row.to_hash
+      ns  = "haproxy #{row['pxname']} #{row['svname']}"
+      row.each do |property, metric|
+        unless (property.nil? || property == 'pxname' || property == 'svname')
+          report(
+            :host    => @uri.host,
+            :service => "#{ns} #{property}",
+            :metric  => metric.to_f,
+            :state   =>  (['UP', 'OPEN'].include?(row['status']) ? 'ok' : 'critical'),
+            :tags    => ['haproxy']
+          )
+        end
+      end
+    end
+  end
+
+  def get_csv
+    http = Net::HTTP.new(@uri.host, @uri.port)
+    http.use_ssl = true if @uri.scheme == 'https'
+    http.start do |h|
+      get = Net::HTTP::Get.new(@uri.request_uri)
+      unless @uri.userinfo.nil?
+        userinfo = @uri.userinfo.split(":")
+        get.basic_auth userinfo[0], userinfo[1]
+      end
+      h.request get
+    end
+  end
+
+end
+
+Riemann::Tools::Haproxy.run

data/bin/riemann-health

@@ -0,0 +1,270 @@
+#!/usr/bin/env ruby
+
+# Reports current CPU, disk, load average, and memory use to riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Health
+  include Riemann::Tools
+
+  opt :cpu_warning, "CPU warning threshold (fraction of total jiffies)", :default => 0.9
+  opt :cpu_critical, "CPU critical threshold (fraction of total jiffies)", :default => 0.95
+  opt :disk_warning, "Disk warning threshold (fraction of space used)", :default => 0.9
+  opt :disk_critical, "Disk critical threshold (fraction of space used)", :default => 0.95
+  opt :load_warning, "Load warning threshold (load average / core)", :default => 3
+  opt :load_critical, "Load critical threshold (load average / core)", :default => 8
+  opt :memory_warning, "Memory warning threshold (fraction of RAM)", :default => 0.85
+  opt :memory_critical, "Memory critical threshold (fraction of RAM)", :default => 0.95
+  opt :checks, "A list of checks to run.", :type => :strings, :default => ['cpu', 'load', 'memory', 'disk']
+
+  def initialize
+    @limits = {
+      :cpu => {:critical => opts[:cpu_critical], :warning => opts[:cpu_warning]},
+      :disk => {:critical => opts[:disk_critical], :warning => opts[:disk_warning]},
+      :load => {:critical => opts[:load_critical], :warning => opts[:load_warning]},
+      :memory => {:critical => opts[:memory_critical], :warning => opts[:memory_warning]}
+    }
+    case (ostype = `uname -s`.chomp.downcase)
+    when 'darwin'
+      @cores = `sysctl -n hw.ncpu`.to_i
+      @cpu = method :darwin_cpu
+      @disk = method :disk
+      @load = method :darwin_load
+      @memory = method :darwin_memory
+      darwin_top
+    when 'freebsd'
+      @cores = `sysctl -n hw.ncpu`.to_i
+      @cpu = method :freebsd_cpu
+      @disk = method :disk
+      @load = method :freebsd_load
+      @memory = method :freebsd_memory
+    else
+      @cores = cores
+      puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == "linux"
+      @cpu = method :linux_cpu
+      @disk = method :disk
+      @load = method :linux_load
+      @memory = method :linux_memory
+    end
+
+    opts[:checks].each do |check|
+      case check
+      when "disk"
+        @disk_enabled = true
+      when "load"
+        @load_enabled = true
+      when "cpu"
+        @cpu_enabled = true
+      when "memory"
+        @memory_enabled = true
+      end
+    end
+  end
+
+  def alert(service, state, metric, description)
+    report(
+      :service => service.to_s,
+      :state => state.to_s,
+      :metric => metric.to_f,
+      :description => description
+    )
+  end
+
+  def cores
+    i = 0;
+    File.read("/proc/cpuinfo").split(/\n\n/).inject({}) do |cores, p|
+      physical_id = p[/physical id\s+:\s+(\d+)/, 1]
+      core_id = p[/core id\s+:\s+(\d+)/, 1]
+      if physical_id and core_id
+        cores["#{physical_id}:#{core_id}"] = true
+      elsif physical_id
+        cores["#{physical_id}:"] = true
+      else
+        cores[i += 1] = true;
+      end
+
+      cores
+    end.size
+  end
+
+  def report_pct(service, fraction, report)
+    if fraction
+      if fraction > @limits[service][:critical]
+        alert service, :critical, fraction, "#{sprintf("%.2f", fraction * 100)}% #{report}"
+      elsif fraction > @limits[service][:warning]
+        alert service, :warning, fraction, "#{sprintf("%.2f", fraction * 100)}% #{report}"
+      else
+        alert service, :ok, fraction, "#{sprintf("%.2f", fraction * 100)}% #{report}"
+      end
+    end
+  end
+
+  def linux_cpu
+    new = File.read('/proc/stat')
+    unless new[/cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/]
+      alert 'cpu', :unknown, nil, "/proc/stat doesn't include a CPU line"
+      return false
+    end
+    u2, n2, s2, i2 = [$1, $2, $3, $4].map { |e| e.to_i }
+
+    if @old_cpu
+      u1, n1, s1, i1 = @old_cpu
+
+      used = (u2+n2+s2) - (u1+n1+s1)
+      total = used + i2-i1
+      fraction = used.to_f / total
+
+      report_pct :cpu, fraction, "user+nice+sytem\n\n#{`ps -eo pcpu,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+    end
+
+    @old_cpu = [u2, n2, s2, i2]
+  end
+
+  def linux_load
+    load = File.read('/proc/loadavg').split(/\s+/)[2].to_f / @cores
+    if load > @limits[:load][:critical]
+      alert "load", :critical, load, "15-minute load average/core is #{load}"
+    elsif load > @limits[:load][:warning]
+      alert "load", :warning, load, "15-minute load average/core is #{load}"
+    else
+      alert "load", :ok, load, "15-minute load average/core is #{load}"
+    end
+  end
+
+  def linux_memory
+    m = File.read('/proc/meminfo').split(/\n/).inject({}) { |info, line|
+      x = line.split(/:?\s+/)
+      # Assume kB...
+      info[x[0]] = x[1].to_i
+      info
+    }
+
+    free = m['MemFree'].to_i + m['Buffers'].to_i + m['Cached'].to_i
+    total = m['MemTotal'].to_i
+    fraction = 1 - (free.to_f / total)
+
+    report_pct :memory, fraction, "used\n\n#{`ps -eo pmem,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def freebsd_cpu
+    u2, n2, s2, t2, i2 = `sysctl -n kern.cp_time 2>/dev/null`.split.map{ |e| e.to_i } #FreeBSD has 5 cpu stats
+
+    if @old_cpu
+      u1, n1, s1, t1, i1 = @old_cpu
+
+      used = (u2+n2+s2+t2) - (u1+n1+s1+t1)
+      total = used + i2-i1
+      fraction = used.to_f / total
+
+      report_pct :cpu, fraction, "user+nice+sytem+interrupt\n\n#{`ps -axo pcpu,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+    end
+
+    @old_cpu = [u2, n2, s2, t2, i2]
+  end
+
+  def freebsd_load
+    m = `uptime`.split[-1].match(/^[0-9]*\.[0-9]*$/)
+    load = m[0].to_f / @cores
+    if load > @limits[:load][:critical]
+      alert "load", :critical, load, "15-minute load average/core is #{load}"
+    elsif load > @limits[:load][:warning]
+      alert "load", :warning, load, "15-minute load average/core is #{load}"
+    else
+      alert "load", :ok, load, "15-minute load average/core is #{load}"
+    end
+  end
+
+  def freebsd_memory
+    meminfo = `sysctl -n vm.stats.vm.v_page_count vm.stats.vm.v_wire_count vm.stats.vm.v_active_count 2>/dev/null`.chomp.split
+    fraction = (meminfo[1].to_f + meminfo[2].to_f) / meminfo[0].to_f
+
+    report_pct :memory, fraction, "used\n\n#{`ps -axo pmem,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def darwin_top
+    raw = `top -l 1 | grep -i "^\\(cpu\\|physmem\\|load\\)"`.chomp
+    @topdata = {:stamp => Time.now.to_i }
+    raw.each_line do |ln|
+      if ln.match(/Load Avg: [0-9.]+, [0-9.]+, ([0-9.])+/i)
+        @topdata[:load] = $1.to_f
+      elsif ln.match(/CPU usage: [0-9.]+% user, [0-9.]+% sys, ([0-9.]+)% idle/i)
+        @topdata[:cpu] = 1  - ($1.to_f / 100)
+      elsif mdat = ln.match(/PhysMem: ([0-9]+)([BKMGT]) wired, ([0-9]+)([BKMGT]) active, ([0-9]+)([BKMGT]) inactive, ([0-9]+)([BKMGT]) used, ([0-9]+)([BKMGT]) free/i)
+        wired = mdat[1].to_i * (1024 ** "BKMGT".index(mdat[2]))
+        active = mdat[3].to_i * (1024 ** "BKMGT".index(mdat[4]))
+        inactive = mdat[5].to_i * (1024 ** "BKMGT".index(mdat[6]))
+        used = mdat[7].to_i * (1024 ** "BKMGT".index(mdat[8]))
+        free = mdat[9].to_i * (1024 ** "BKMGT".index(mdat[10]))
+        @topdata[:memory] = (wired + active + used).to_f / (wired + active + used + inactive + free)
+      end
+    end
+  end
+
+  def darwin_cpu
+    darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
+    unless @topdata[:cpu]
+      alert 'cpu', :unknown, nil, "unable to get CPU stats from top"
+      return false
+    end
+    report_pct :cpu,  @topdata[:cpu], "usage\n\n#{`ps -eo pcpu,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def darwin_load
+    darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
+    unless @topdata[:load]
+      alert 'load', :unknown, nil, "unable to get load ave from top"
+      return false
+    end
+    metric = @topdata[:load] / @cores
+    if metric > @limits[:load][:critical]
+      alert "load", :critical, metric, "15-minute load average per core is #{metric}"
+    elsif metric > @limits[:load][:warning]
+      alert "load", :warning, metric, "15-minute load average per core is #{metric}"
+    else
+      alert "load", :ok, metric, "15-minute load average per core is #{metric}"
+    end
+  end
+
+  def darwin_memory
+    darwin_top unless (Time.now.to_i - @topdata[:stamp]) < opts[:interval]
+    unless @topdata[:memory]
+      alert 'memory', :unknown, nil, "unable to get memory data from top"
+      return false
+    end
+    report_pct :memory,  @topdata[:memory], "usage\n\n#{`ps -eo pmem,pid,comm | sort -nrb -k1 | head -10`.chomp}"
+  end
+
+  def disk
+    `df -P`.split(/\n/).each do |r|
+      f = r.split(/\s+/)
+      next unless f[0] =~ /^\//
+        next if f[0] == 'Filesystem'
+      x = f[4].to_f/100
+
+      if x > @limits[:disk][:critical]
+        alert "disk #{f[5]}", :critical, x, "#{f[4]} used"
+      elsif x > @limits[:disk][:warning]
+        alert "disk #{f[5]}", :warning, x, "#{f[4]} used"
+      else
+        alert "disk #{f[5]}", :ok, x, "#{f[4]} used"
+      end
+    end
+  end
+
+  def tick
+    if @cpu_enabled
+      @cpu.call
+    end
+    if @memory_enabled
+      @memory.call
+    end
+    if @disk_enabled
+      @disk.call
+    end
+    if @load_enabled
+      @load.call
+    end
+  end
+end
+
+Riemann::Tools::Health.run

data/bin/riemann-kvminstance

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::KVM
+  include Riemann::Tools
+
+  def tick
+
+  #determine how many instances I have according to libvirt
+  kvm_instances = %x[virsh list |grep i-|wc -l]
+
+  #submit them to riemann
+  report(
+     :service => "KVM Running VMs",
+     :metric => kvm_instances.to_i,
+     :state => "info"
+       )
+  end
+end
+
+Riemann::Tools::KVM.run

data/bin/riemann-memcached

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+# Gathers memcached STATS and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Memcached
+  include Riemann::Tools
+  require 'socket'
+
+  opt :memcached_host, "Memcached hostname", :default => 'localhost'
+  opt :memcached_port, "Memcached port", :default => 11211
+
+  def tick
+    sock = TCPSocket.new(opts[:memcached_host], opts[:memcached_port])
+    sock.print("stats\r\n")
+    sock.flush
+    stats = sock.gets
+
+    data = {}
+    while true
+      stats = sock.gets
+      break if stats.strip == 'END'
+      m = stats.match /STAT (\w+) (\S+)/
+      report(
+             :host => opts[:memcached_host].dup,
+             :service => "memcached #{m[1]}",
+             :metric => m[2].to_f,
+             :state => 'ok',
+             :tags => ['memcached']
+             )
+    end
+    sock.close
+  end
+end
+
+Riemann::Tools::Memcached.run