riemann-tools 0.0.8 → 0.0.9

data/bin/riemann-bench

@@ -10,14 +10,16 @@ class Riemann::Bench
   attr_accessor :client, :hosts, :services, :states
   def initialize
     @hosts = [nil] + (0...10).map { |i| "host#{i}" }
-    @hosts = ['test']
-    @services = %w(per)
+    @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 = rand
+    m = state[:metric] + (rand - 0.5) * 0.1
+    m = [[0,m].max, 1].min
+
     s = case m
     when 0...0.75
       'ok'
@@ -28,7 +30,7 @@ class Riemann::Bench
     end
 
     {
-      metric_f: m,
+      metric: m,
       state: s,
       host: state[:host],
       service: state[:service],
@@ -46,7 +48,7 @@ class Riemann::Bench
   def run
     start
     loop do
-#      sleep 0.01
+      sleep 0.05
       tick
     end
   end
@@ -54,7 +56,7 @@ class Riemann::Bench
   def start
     hosts.product(services).each do |host, service|
       states[[host, service]] = {
-        metric_f: 0.5,
+        metric: 0.5,
         state: 'ok',
         description: "Starting up",
         host: host,

data/bin/riemann-cloudant

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+# Gathers load balancer statistics from Cloudant.com (shared cluster) and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Cloudant
+  include Riemann::Tools
+  require 'net/http'
+  require 'json'
+
+  opt :cloudant_username, "Cloudant username", :type => :string, :required => true
+  opt :cloudant_password, "Cloudant pasword", :type => :string, :required => true
+
+  def tick
+    json = JSON.parse(get_json().body)
+    json.each do |node|
+      return if node['svname'] == 'BACKEND' # this is just a sum of all nodes.
+
+      ns = "cloudant #{node['pxname']}"
+      cluster_name = node['tracked'].split('.')[0] # ie: meritage.cloudant.com
+
+      # report health of each node.
+      report(
+        :service => ns,
+        :state   => (node['status'] == 'UP' ? 'ok' : 'critical'),
+        :tags    => ['cloudant', cluster_name]
+      )
+
+      # report property->metric of each node.
+      node.each do |property, metric|
+        unless ['pxname', 'svname', 'status', 'tracked'].include?(property)
+          report(
+            :host    => node['tracked'],
+            :service => "#{ns} #{property}",
+            :metric  => metric.to_f,
+            :state   => (node['status'] == 'UP' ? 'ok' : 'critical'),
+            :tags    => ['cloudant', cluster_name]
+          )
+        end
+      end
+
+    end
+  end
+
+   def get_json
+    http = Net::HTTP.new('cloudant.com', 443)
+    http.use_ssl = true
+      http.start do |h|
+        get = Net::HTTP::Get.new('/api/load_balancer')
+        get.basic_auth opts[:cloudant_username], opts[:cloudant_password]
+        h.request get
+     end
+   end
+
+end
+
+Riemann::Tools::Cloudant.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-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 == '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

@@ -6,7 +6,7 @@ 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
@@ -23,11 +23,33 @@ class Riemann::Tools::Health
       :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
   end
 
   def alert(service, state, metric, description)
     report(
-      :service => service,
+      :service => service.to_s,
       :state => state.to_s,
       :metric => metric.to_f,
       :description => description
@@ -51,14 +73,26 @@ class Riemann::Tools::Health
     end.size
   end
 
-  def cpu
+  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
 
@@ -66,41 +100,14 @@ class Riemann::Tools::Health
       total = used + i2-i1
       fraction = used.to_f / total
 
-      if fraction > @limits[:cpu][:critical]
-        alert "cpu", :critical, fraction, "#{sprintf("%.2f", fraction * 100)}% user+nice+sytem\n\n#{cpu_report}"
-      elsif fraction > @limits[:cpu][:warning]
-        alert "cpu", :warning, fraction, "#{sprintf("%.2f", fraction * 100)}% user+nice+sytem\n\n#{cpu_report}"
-      else
-        alert "cpu", :ok, fraction, "#{sprintf("%.2f", fraction * 100)}% user+nice+sytem\n\n#{cpu_report}"
-      end
+      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 cpu_report
-    `ps -eo pcpu,pid,args | sort -nrb -k1 | head -10`.chomp
+    @old_cpu = [u2, n2, s2, i2]
   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 load
-    load = File.read('/proc/loadavg').split(/\s+/)[2].to_f / cores
+  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]
@@ -110,7 +117,7 @@ class Riemann::Tools::Health
     end
   end
 
-  def memory
+  def linux_memory
     m = File.read('/proc/meminfo').split(/\n/).inject({}) { |info, line|
       x = line.split(/:?\s+/)
       # Assume kB...
@@ -118,29 +125,124 @@ class Riemann::Tools::Health
       info
     }
 
-    free = m['MemFree'] + m['Buffers'] + m['Cached']
-    total = m['MemTotal']
+    free = m['MemFree'].to_i + m['Buffers'].to_i + m['Cached'].to_i
+    total = m['MemTotal'].to_i
     fraction = 1 - (free.to_f / total)
 
-    if fraction > @limits[:memory][:critical]
-      alert "memory", :critical, fraction, "#{sprintf("%.2f", fraction * 100)}% used\n\n#{memory_report}"
-    elsif fraction > @limits[:memory][:warning]
-      alert "memory", :warning, fraction, "#{sprintf("%.2f", fraction * 100)}% used\n\n#{memory_report}"
+    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 "memory", :ok, fraction, "#{sprintf("%.2f", fraction * 100)}% used\n\n#{memory_report}"
+      alert "load", :ok, load, "15-minute load average/core is #{load}"
     end
   end
 
-  def memory_report
-    `ps -eo pmem,pid,args | sort -nrb -k1 | head -10`.chomp
+  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
-    cpu
-    memory
-    load
-    disk
+    @cpu.call
+    @memory.call
+    @disk.call
+    @load.call
   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-kvminstances

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

@@ -0,0 +1,34 @@
+#!/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 => ''
+
+  def initialize
+    @redis = ::Redis.new(:host => opts[:redis_host], :port => opts[:redis_port])
+    @redis.auth(opts[:redis_password]) unless opts[:redis_password] == ''
+  end
+
+  def tick
+    @redis.info.each do |property, value|
+      report(
+        :host    => opts[:redis_host],
+        :service => "redis #{property}",
+        :metric  => value.to_f,
+        :state   => 'ok',
+        :tags    => ['redis']
+      )
+    end
+  end
+
+end
+
+Riemann::Tools::Redis.run

data/lib/riemann/tools.rb

@@ -29,6 +29,8 @@ module Riemann
         opt :host, "Riemann host", :default => '127.0.0.1'
         opt :port, "Riemann port", :default => 5555
         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
       end
     end
 
@@ -52,6 +54,14 @@ module Riemann
     end
 
     def report(event)
+      if options[:tag]
+        event[:tags] = options[:tag]
+      end
+      
+      if options[:ttl]
+        event[:ttl] = options[:ttl]
+      end
+
       riemann << event
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riemann-tools
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,27 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-23 00:00:00.000000000 Z
+date: 2012-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riemann-client
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &10179640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.0.8
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.0.7
+  version_requirements: *10179640
 - !ruby/object:Gem::Dependency
   name: trollop
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &10178820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -37,15 +32,10 @@ dependencies:
         version: 1.16.2
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.16.2
+  version_requirements: *10178820
 - !ruby/object:Gem::Dependency
   name: munin-ruby
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &10177620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -53,15 +43,10 @@ dependencies:
         version: 0.2.1
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.2.1
+  version_requirements: *10177620
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &10176660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -69,33 +54,51 @@ dependencies:
         version: 1.1.0
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  version_requirements: *10176660
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &10606920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *10606920
 description: 
 email: aphyr@aphyr.com
 executables:
-- riemann-net
-- riemann-riak-ring
-- riemann-riak-keys
 - riemann-munin
-- riemann-riak
 - riemann-bench
+- riemann-riak
 - riemann-health
+- riemann-haproxy
+- riemann-riak-keys
+- riemann-diskstats
+- riemann-riak-ring
+- riemann-cloudant
+- riemann-kvminstances
+- riemann-kvminstance
+- riemann-net
+- riemann-redis
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/riemann/tools.rb
-- bin/riemann-net
-- bin/riemann-riak-ring
-- bin/riemann-riak-keys
 - bin/riemann-munin
-- bin/riemann-riak
 - bin/riemann-bench
+- bin/riemann-riak
 - bin/riemann-health
+- bin/riemann-haproxy
+- bin/riemann-riak-keys
+- bin/riemann-diskstats
+- bin/riemann-riak-ring
+- bin/riemann-cloudant
+- bin/riemann-kvminstances
+- bin/riemann-kvminstance
+- bin/riemann-net
+- bin/riemann-redis
 - LICENSE
 - README.markdown
 homepage: https://github.com/aphyr/riemann-tools
@@ -118,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: riemann-tools
-rubygems_version: 1.8.22
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Utilities which submit events to Riemann.