riemann-tools-dgvz 0.2.2.1

data/bin/riemann-elb-metrics

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+$0 = __FILE__
+
+class Riemann::Tools::ELBMetrics
+  include Riemann::Tools
+
+  require 'fog'
+  require 'time'
+
+  opt :fog_credentials_file, "Fog credentials file", :type => String
+  opt :fog_credential, "Fog credentials to use", :type => String
+  opt :aws_access, "AWS Access Key", :type => String
+  opt :aws_secret, "AWS Secret Key", :type => String
+  opt :aws_region, "AWS Region", :type => String, :default => "eu-west-1"
+  opt :aws_azs, "List of AZs to aggregate against", :type => :strings, :default => [ "all_az" ]
+  opt :elbs, "List of ELBs to pull metrics from", :type => :strings, :required => true
+
+  def standard_metrics
+    # ELB metric types, from:
+    # http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html#elb-metricscollected
+    metric_options = {
+      "Latency" => {
+        "Unit" => "Seconds",
+        "Statistics" => ["Maximum", "Minimum", "Average" ]
+      },
+      "RequestCount" => {
+        "Unit" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HealthyHostCount" => {
+        "Units" => "Count",
+        "Statistics" => [ "Minimum", "Maximum", "Average" ]
+      },
+      "UnHealthyHostCount" => {
+        "Units" => "Count",
+        "Statistics" => [ "Minimum", "Maximum", "Average" ]
+      },
+      "HTTPCode_ELB_4XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_ELB_5XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_2XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_3XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_4XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_5XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      }
+    }
+
+    metric_options
+  end
+
+  def base_metrics
+    # get last 60 seconds
+    start_time = (Time.now.utc - 60).iso8601
+    end_time = Time.now.utc.iso8601
+
+    # The base query that all metrics would get
+    metric_base = {
+      "Namespace" => "AWS/ELB",
+      "StartTime" => start_time,
+      "EndTime" => end_time,
+      "Period" => 60,
+    }
+
+    metric_base
+  end
+
+
+  def tick
+    if options[:fog_credentials_file]
+      Fog.credentials_path = options[:fog_credentials_file]
+      Fog.credential = options[:fog_credential].to_sym
+      connection = Fog::AWS::CloudWatch.new
+    else
+      connection = Fog::AWS::CloudWatch.new({
+        :aws_access_key_id => options[:aws_access],
+        :aws_secret_access_key => options[:aws_secret],
+        :region => options[:aws_region]
+      })
+    end
+
+    options[:elbs].each do |lb|
+
+      metric_options = standard_metrics
+      metric_base_options = base_metrics
+
+      options[:aws_azs].each do |az|
+        metric_options.keys.sort.each do |metric_type|
+          merged_options = metric_base_options.merge(metric_options[metric_type])
+          merged_options["MetricName"] = metric_type
+          if az == "all_az"
+            merged_options["Dimensions"] = [ { "Name" => "LoadBalancerName", "Value" => lb } ]
+          else
+            merged_options["Dimensions"] = [
+              { "Name" => "LoadBalancerName", "Value" => lb },
+              { "Name" => "AvailabilityZone" , "Value" => az}
+            ]
+          end
+
+          result = connection.get_metric_statistics(merged_options)
+
+          # "If no response codes in the category 2XX-5XX range are sent to clients within 
+          # the given time period, values for these metrics will not be recorded in CloudWatch"
+          #next if result.body["GetMetricStatisticsResult"]["Datapoints"].empty? && metric_type =~ /[2345]XX/
+          #
+          # BUG:
+          # Metrics are reported every 60 seconds, but sometimes there isn't one there yet.
+          # We can skip that, or do something else?
+          next if result.body["GetMetricStatisticsResult"]["Datapoints"].empty?
+
+          # We should only ever have a single data point
+          result.body["GetMetricStatisticsResult"]["Datapoints"][0].keys.sort.each do |stat_type|
+            next if stat_type == "Unit"
+            next if stat_type == "Timestamp"
+
+            unit = result.body["GetMetricStatisticsResult"]["Datapoints"][0]["Unit"]
+            metric = result.body["GetMetricStatisticsResult"]["Datapoints"][0][stat_type]
+            event = Hash.new
+            event = {
+              host: lb,
+              service: "elb.#{az}.#{metric_type}.#{stat_type}",
+              ttl: 60,
+              description: "#{lb} #{metric_type} #{stat_type} (#{unit})",
+              tags: [ "production", "elb_metrics" ],
+              metric: metric
+            }
+
+            report(event)
+          end
+        end
+      end
+    end
+  end
+end
+
+Riemann::Tools::ELBMetrics.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-freeswitch

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::FreeSWITCH
+  include Riemann::Tools
+
+  opt :calls_warning, "Calls warning threshold", :default => 100
+  opt :calls_critical, "Calls critical threshold", :default => 300
+  opt :pid_file, "FreeSWITCH daemon pidfile", :type => String, :default => "/var/run/freeswitch/freeswitch.pid"
+
+  def initialize
+    @limits = {
+      :calls => {:critical => opts[:calls_critical], :warning => opts[:calls_warning]}
+    }
+  end
+
+  def dead_proc?(pid)
+    begin
+      Process.getpgid(pid)
+      false
+    rescue Errno::ESRCH
+      true
+    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 tick
+    # Determine how many current calls I have according to FreeSWITCH
+    fs_calls = %x[fs_cli -x "show calls count"| grep -Po '^\\d+'].to_i
+
+    # Determine how many current channels I have according to FreeSWITCH
+    fs_channels = %x[fs_cli -x "show channels count"| grep -Po '^\\d+'].to_i
+
+    # Try to read pidfile. If it fails use Devil's dummy PID
+    begin
+      fs_pid = File.read(opts[:pid_file]).to_i
+    rescue
+      puts "Couldn't read pidfile: #{opts[:pid_file]}"
+      fs_pid = -666
+    end
+
+    # Submit calls to riemann
+    if fs_calls > @limits[:calls][:critical]
+      alert "FreeSWITCH current calls", :critical, fs_calls, "Number of calls are #{fs_calls}"
+    elsif fs_calls > @limits[:calls][:warning]
+      alert "FreeSWITCH current calls", :warning, fs_calls, "Number of calls are #{fs_calls}"
+    else
+      alert "FreeSWITCH current calls", :ok, fs_calls, "Number of calls are #{fs_calls}"
+    end
+
+    # Submit channels to riemann
+    if fs_channels > @limits[:calls][:critical]
+      alert "FreeSWITCH current channels", :critical, fs_channels, "Number of channels are #{fs_channels}"
+    elsif fs_channels > @limits[:calls][:warning]
+      alert "FreeSWITCH current channels", :warning, fs_channels, "Number of channels are #{fs_channels}"
+    else
+      alert "FreeSWITCH current channels", :ok, fs_channels, "Number of channels are #{fs_channels}"
+    end
+
+    # Submit status to riemann
+    if dead_proc?(fs_pid)
+      alert "FreeSWITCH status", :critical, -1, "FreeSWITCH service status: not running"
+    else
+      alert "FreeSWITCH status", :ok, nil, "FreeSWITCH service status: running"
+    end
+
+  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,272 @@
+#!/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+system\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 if f[0] == 'Filesystem'
+      next unless f[0] =~ /\// # Needs at least one slash in the mount path
+
+      # Calculate capacity
+      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