riemann-tools-fb 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 25dce28ceece7fa46dec1e11f34c25cd635755da
+  data.tar.gz: d9a177ddf05988aa078e2af1e5cd715487791856
+SHA512:
+  metadata.gz: 81e9be74305a81fc5befef9f73afd37e34146a3a9ce117f88f398322226175a6d1742d8cda90bf250689961fed69cd710b2337a1a2e404cc9df577fec7d9a1f7
+  data.tar.gz: b1c56956e9f9dce4c891a59fba51a5769c38ce327a16c320737f4eb64bca7a0ae637d747fa00c1b17a9b65e81f8893c08e23988ee731e1a0955cee99cb6cfec6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Kyle Kingsbury
+
+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.markdown

@@ -0,0 +1,18 @@
+Riemann Tools
+=============
+
+Tiny programs to submit events to Riemann.
+
+Riemann-health, for example, submits events about the current CPU, load,
+memory, and disk use. Bench submits randomly distributed metrics for load
+testing. I've got a whole bunch of these internally for monitoring Redis, Riak,
+queues, etc. Most have internal configuration dependencies, so it'll be a while
+before I can extract them for re-use.
+
+Get started
+==========
+
+``` bash
+gem install riemann-tools
+riemann-health --host my.riemann.server
+```

data/bin/riemann-bench

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+# Connects to a server (first arg) and populates it with a constant stream of
+# events for testing.
+
+require 'rubygems'
+require 'riemann/client'
+require 'pp'
+
+class Riemann::Bench
+  attr_accessor :client, :hosts, :services, :states
+  def initialize
+    @hosts = [nil] + (0...10).map { |i| "host#{i}" }
+    @hosts = %w(a b c d e f g h i j)
+    @services = %w(test1 test2 test3 foo bar baz xyzzy attack cat treat)
+    @states = {}
+    @client = Riemann::Client.new(:host => (ARGV.first || 'localhost'))
+  end
+
+  def evolve(state)
+    m = state[:metric] + (rand - 0.5) * 0.1
+    m = [[0,m].max, 1].min
+
+    s = case m
+    when 0...0.75
+      'ok'
+    when 0.75...0.9
+      'warning'
+    when 0.9..1.0
+      'critical'
+    end
+
+    {
+      :metric => m,
+      :state => s,
+      :host => state[:host],
+      :service => state[:service],
+      :description => "at #{Time.now}"
+    }
+  end
+  
+  def tick
+#    pp @states
+    hosts.product(services).each do |id|
+      client << (states[id] = evolve(states[id]))
+    end
+  end
+
+  def run
+    start
+    loop do
+      sleep 0.05
+      tick
+    end
+  end
+
+  def start
+    hosts.product(services).each do |host, service|
+      states[[host, service]] = {
+        :metric => 0.5,
+        :state => 'ok',
+        :description => "Starting up",
+        :host => host,
+        :service => service
+      }
+    end
+  end
+end
+
+Riemann::Bench.new.run

data/bin/riemann-diskstats

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+#
+require 'rubygems'
+require 'riemann/tools'
+
+class Riemann::Tools::Diskstats
+  include Riemann::Tools
+
+  opt :devices, "Devices to monitor", :type => :strings, :default => nil
+  opt :ignore_devices, "Devices to ignore", :type => :strings, :default =>nil
+
+  def initialize
+    @old_state = nil
+  end
+
+  def state
+    f = File.read('/proc/diskstats')
+    state = f.split("\n").reject { |d| d =~ /(ram|loop)/ }.inject({}) do |s, line|
+      if line =~ /^(?:\s+\d+){2}\s+([\w\d\-]+) (.*)$/
+        dev = $1
+
+        ['reads reqs',
+        'reads merged',
+        'reads sector',
+        'reads time',
+        'writes reqs',
+        'writes merged',
+        'writes sector',
+        'writes time',
+        'io reqs',
+        'io time',
+        'io weighted'
+        ].map do |service|
+          "#{dev} #{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 = opts[:devices]
+      state = state.select do |service, value|
+        is.include? service.split(' ').first
+      end
+    end
+
+    if ign = opts[:ignore_devices]
+      state = state.reject do |service, value|
+        ign.include? service.split(' ').first
+      end
+    end
+
+    state
+  end
+
+  def tick
+    state = self.state
+
+    if @old_state
+      state.each do |service, metric|
+        delta = metric - @old_state[service]
+
+        report(
+          :service => "diskstats " + service,
+          :metric => (delta.to_f / opts[:interval]),
+          :state => "ok"
+        )
+
+        if service =~ /io time$/
+          report(:service => "diskstats " + service.gsub(/time/, 'util'),
+                 :metric => (delta.to_f / (opts[:interval]*1000)),
+                 :state => "ok")
+        end
+      end
+    end
+
+    @old_state = state
+  end
+end
+
+Riemann::Tools::Diskstats.run

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-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+/)[0].to_f / @cores
+    if load > @limits[:load][:critical]
+      alert "load", :critical, load, "1-minute load average/core is #{load}"
+    elsif load > @limits[:load][:warning]
+      alert "load", :warning, load, "1-minute load average/core is #{load}"
+    else
+      alert "load", :ok, load, "1-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].chomp.gsub(/\s+/,'').split(',')
+    load = m[0].to_f / @cores
+    if load > @limits[:load][:critical]
+      alert "load", :critical, load, "1-minute load average/core is #{load}"
+    elsif load > @limits[:load][:warning]
+      alert "load", :warning, load, "1-minute load average/core is #{load}"
+    else
+      alert "load", :ok, load, "1-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, "1-minute load average per core is #{metric}"
+    elsif metric > @limits[:load][:warning]
+      alert "load", :warning, metric, "1-minute load average per core is #{metric}"
+    else
+      alert "load", :ok, metric, "1-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-net

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+# Gathers net 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-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/lib/riemann/tools.rb

@@ -0,0 +1,132 @@
+module Riemann
+  module Tools
+    require 'rubygems'
+    require 'trollop'
+    require 'riemann/client'
+    require 'timeout'
+
+    def self.included(base)
+      base.instance_eval do
+        def run
+          new.run
+        end
+
+        def opt(*a)
+          a.unshift :opt
+          @opts ||= []
+          @opts << a
+        end
+
+        def options
+          p = Trollop::Parser.new
+          @opts.each do |o|
+            p.send *o
+          end
+          Trollop::with_standard_exception_handling(p) do
+            p.parse ARGV
+          end
+        end
+
+        opt :host, "Riemann host", :default => '127.0.0.1'
+        opt :port, "Riemann port", :default => 5555
+        opt :event_host, "Event hostname", :type => String
+        opt :interval, "Seconds between updates", :default => 5
+        opt :tag, "Tag to add to events", :type => String, :multi => true
+        opt :ttl, "TTL for events", :type => Integer
+        opt :attribute, "Attribute to add to the event", :type => String, :multi => true
+        opt :timeout, "Timeout (in seconds) when waiting for acknowledgements", :default => 30
+        opt :tcp, "Use TCP transport instead of UDP (improves reliability, slight overhead.", :default => true
+        opt :daemon, "Run in background", :default => false
+        opt :logfile, "logfile path", :type => String, :default => '/tmp/riemann-tools.log'
+        opt :pidfile, "pidfile path", :type => String, :default => '/tmp/riemann-tools.pid'
+      end
+    end
+
+    # Returns parsed options (cached) from command line.
+    def options
+      @options ||= self.class.options
+    end
+    alias :opts :options
+
+    def attributes
+      @attributes ||= Hash[options[:attribute].map do |attr|
+        k,v = attr.split(/=/)
+        if k and v
+          [k,v]
+        end
+      end]
+    end
+
+    def report(event)
+      if options[:tag]
+        # Work around a bug with beefcake which can't take frozen strings.
+        event[:tags] = options[:tag].map(&:dup)
+      end
+
+      event[:ttl] ||= (options[:ttl] || (options[:interval] * 2))
+
+      if options[:event_host]
+        event[:host] = options[:event_host].dup
+      end
+
+      event = event.merge(attributes)
+
+      begin
+        Timeout::timeout(options[:timeout]) do
+          riemann << event
+        end
+      rescue Timeout::Error
+        riemann.connect
+      end
+    end
+
+    def new_riemann_client
+      r = Riemann::Client.new(
+        :host => options[:host],
+        :port => options[:port]
+      )
+      if options[:tcp]
+        r.tcp
+      else
+        r
+      end
+    end
+
+    def riemann
+      @riemann ||= new_riemann_client
+    end
+    alias :r :riemann
+
+    def run
+      daemonize if options[:daemon]
+      t0 = Time.now
+      loop do
+        begin
+          tick
+        rescue => e
+          $stderr.puts "#{e.class} #{e}\n#{e.backtrace.join "\n"}"
+        end
+
+        # Sleep.
+        sleep(options[:interval] - ((Time.now - t0) % options[:interval]))
+      end
+    end
+
+    def daemonize
+      exit if fork
+      Process.setsid
+      $0 = self.class.name.downcase.gsub('::','_')
+      $stdout.reopen(opts[:logfile], 'w')
+      $stdout.sync = true
+      $stderr.reopen($stdout)
+      exit if fork
+      f = File.new(opts[:pidfile], 'w')
+      f.write Process.pid
+      f.close
+    end
+
+    def tick
+    end
+
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: riemann-tools-fb
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Fede Borgnia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: riemann-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.16.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.16.2
+description: Utilities which submit events to Riemann.
+email: fborgnia@gmail.com
+executables:
+- riemann-bench
+- riemann-diskstats
+- riemann-proc
+- riemann-health
+- riemann-fd
+- riemann-net
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/riemann/tools.rb
+- bin/riemann-bench
+- bin/riemann-diskstats
+- bin/riemann-fd
+- bin/riemann-health
+- bin/riemann-net
+- bin/riemann-proc
+- LICENSE
+- README.markdown
+homepage: https://github.com/fborgnia/riemann-tools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: riemann-tools
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Utilities which submit events to Riemann.
+test_files: []