riemann-monitors 0.0.1

data/bin/riemann-kvminstance

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::KVM
+  include Riemann::Monitors
+
+  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::Monitors::KVM.run

data/bin/riemann-memcached

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+# Gathers memcached STATS and submits them to Riemann.
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Memcached
+  include Riemann::Monitors
+  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::Monitors::Memcached.run

data/bin/riemann-net

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+# Gathers network interface statistics and submits them to Riemann.
+
+require "pry"
+require_relative "../lib/riemann-monitors"
+require 'set'
+
+class Riemann::Monitors::Net
+  include Riemann::Monitors
+
+  opt :interfaces, "Interfaces to monitor", :type => :strings, :default => []
+  opt :ignore_interfaces, "Interfaces to ignore", :type => :strings, :default =>['lo']
+
+  def initialize
+    @old_state = nil
+    @fields = ["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"]
+    @use_interfaces = Set.new(opts[:interfaces])
+    @ignore_interfaces = Set.new(opts[:ignore_interfaces])
+  end
+
+  def state
+    net = File.open("/proc/net/dev", "r")
+    net.readline ; net.readline  # Skip first two lines.
+
+    metrics = {}
+    net.readlines.each do |line|
+      interface = line[/^[^:]+/]
+      if @use_interfaces.include?(interface) && !@ignore_interfaces.include?(interface)
+        metrics[interface] = @fields.zip(line.split(/\s+/).drop(1).map(&:to_i)).to_h
+      end
+    end
+    metrics
+  end
+
+  # TODO
+  def tick
+    state = self.state
+
+    if @old_state
+      # Report services from `@old_state` that don't exist in `state` as expired
+      @old_state.reject { |k| state.has_key?(k) }.each do |service, metric|
+        report(:service => service.dup, :state => 'expired')
+      end
+
+      # Report delta for services that have values in both `@old_state` and `state`
+      state.each do |service, metric|
+        next unless @old_state.has_key?(service)
+
+        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::Monitors::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_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::NginxStatus
+  include Riemann::Monitors
+  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::Monitors::NginxStatus.run

data/bin/riemann-ntp

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+# Reports NTP stats to Riemann.
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Ntp
+  include Riemann::Monitors
+
+  def initialize
+    @hostname = Socket.gethostname
+  end
+
+  def tick
+    stats = `ntpq -p -n`
+    stats.each_line do |stat|
+      m = stat.split()
+      next if m.grep(/^===/).any? || m.grep(/^remote/).any?
+      @ntp_host = m[0].gsub("*","").gsub("-","").gsub("+","")
+      send("delay",m[7])
+      send("offset",m[8])
+      send("jitter",m[9])
+    end
+  end
+
+  def send(type,metric)
+      report(host: @hostname,
+            service: "ntp/#{type}",
+            metric: metric.to_f,
+            description: @ntp_host.to_s,
+            tags: ["ntp"])
+  end
+end
+
+Riemann::Monitors::Ntp.run

data/bin/riemann-proc

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+# Reports running process count to riemann.
+
+require 'pry'
+require 'set'
+require_relative "../lib/riemann-monitors"
+
+# $clk_tck = Etc.sysconf(2).to_f
+
+ProcessInfo = Struct.new(:pid, :comm, :oldfields, :newfields) do
+  def riemann_statemap(state)
+    statemap = {"R" => "ok",
+                "S" => "ok",
+                "I" => "warning",
+                "T" => "critical",
+                "U" => "critical",
+                "Z" => "critical"}
+    statemap.default = "unknown"
+    statemap[state]
+  end
+
+  def fields
+    @sorted_fields ||= (oldfields + newfields).sort
+  end
+
+  # def time_of(field)
+  #   fields.assoc(field).last / $clk_tck
+  # end
+
+  def summarize()
+    fields.each do |name, metric|
+      params = {}
+      params[:service] = "process;#{pid};#{name}"
+      params[:description] = name
+      params[:pname] = comm
+      if name == "State"
+        params[:state] = riemann_statemap(metric)
+        params[:value] = metric
+      # elsif name.end_with?("time")
+      #   params[:metric] = time_of(name)
+      elsif metric.is_a?(Numeric)
+        params[:metric] = metric
+      else
+        params[:value] = metric
+      end
+      yield(params)
+    end
+  end
+end
+
+class Riemann::Monitors::Proc
+  include Riemann::Monitors
+
+  opt(:proc_regex, "regular expression that matches the process to be monitored", type: :string, default: ".*")
+  opt(:newstats, "fields from /proc/#/status to collect (always includes name and status character)", multi: :strings,
+      default: ["VmRSS", "VmSize", "VmPeak", "VmHWM", "VmLib", "VmSwap", "Threads"])
+  opt(:oldstats, "fields from /proc/#/status to collect (use names from proc(5) manpage)", multi: :strings, default: ["utime", "stime"])
+  opt(:metricfield, "field to assign to metric", default: "VmRSS")
+  opt(:proc_min_critical, "running process count minimum", :default => 0)
+  opt(:proc_max_critical, "running process count maximum", :default => 65536)
+
+  def initialize
+    @process_regex = Regexp.new(opts[:proc_regex])
+    @newfields = Set.new(opts[:newstats]).add("Name").add("State")
+    @oldfields = Set.new(opts[:oldstats])
+    @allstatfields = File.readlines(File.join(__dir__, "..", "data", "statfields")).map(&:chomp)
+
+    @limits = { :critical => Range.new(opts[:proc_min_critical], opts[:proc_max_critical]) }
+
+    abort "FATAL: specify a process regular expression, see --help for usage" unless opts[:proc_regex]
+  end
+
+  def tick
+    @sample_start = Time.now
+
+    processes = Dir.glob("/proc/[0-9]*/comm").map {|cfile|
+      pid = cfile[/\d+/].to_i
+      comm = File.read(cfile).chomp
+      if @process_regex.match(comm)
+        p = ProcessInfo.new()
+        p.pid = pid
+        p.comm = comm
+        p
+      end
+    }.compact
+
+    processes.each {|p|
+      p.newfields = File.readlines("/proc/#{p.pid}/status") \
+                        .map {|line| parts = line.split(/\s+/)
+                                name, rest = parts[0].chop, parts[1..-1]
+                                if @newfields.include?(name)
+                                  value = rest&.first
+                                  if rest.length > 2
+                                    value = rest.join("\t")
+                                  elsif value[/\A\d+\z/]
+                                    value = value.to_i
+                                  end
+                                  [name, value]
+                                end
+                        }.compact
+    }
+
+    processes.each {|p|
+      statstr = File.read("/proc/#{p.pid}/stat")
+      stat_tail = statstr.reverse[/[-0-9 ]+/].reverse.split(" ").map {|n| n.to_i }
+      p.oldfields = @allstatfields.zip(stat_tail).select {|name, value| @oldfields.include?(name) }
+    }
+    @sample_end = Time.now
+
+    report(service: "process.samplerate", state: "ok", metric: (@sample_end.to_f - @sample_start.to_f), time: @sample_end)
+
+    processes.group_by {|p| p.comm }.map do |pname, ps|
+      running = ps.count
+      if @limits[:critical].cover?(running)
+        report(service: "process.instances", state: "ok", description: pname, metric: running)
+      else
+        report(service: "process.instances", state: "critical", description: pname, metric: running)
+      end
+    end
+
+    processes.each do |p|
+      p.summarize do |point|
+        point[:time] = @sample_end
+        report(point)
+      end
+    end
+  end
+end
+
+Riemann::Monitors::Proc.run

data/bin/riemann-varnish

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+# Reports varnish stats to Riemann.
+
+require 'open3'
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Varnish
+  include Riemann::Monitors
+
+  opt :varnish_host, "Varnish hostname", :default => `hostname`.chomp
+
+  def initialize
+    cmd = 'varnishstat -V'
+    Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+      @ver = /varnishstat \(varnish-(\d+)/.match(stderr.read)[1].to_i
+    end
+
+    if @ver >= 4
+      @vstats = [ "MAIN.sess_conn",
+                "MAIN.sess_drop ",
+                "MAIN.client_req",
+                "MAIN.cache_hit",
+                "MAIN.cache_miss" ]
+    else
+      @vstats = [ "client_conn",
+                "client_drop",
+                "client_req",
+                "cache_hit",
+                "cache_miss" ]
+    end
+  end
+
+  def tick
+    if @ver >= 4
+      stats = `varnishstat -1 -f #{@vstats.join(" -f ")}`
+    else
+      stats = `varnishstat -1 -f #{@vstats.join(",")}`
+    end
+    stats.each_line do |stat|
+      m = stat.split()
+      report(
+             :host => opts[:varnish_host].dup,
+             :service => "varnish #{m[0]}",
+             :metric => m[1].to_f,
+             :state => "ok",
+             :description => "#{m[3..-1].join(' ')}",
+             :tags => ["varnish"]
+            )
+    end
+  end
+end
+
+Riemann::Monitors::Varnish.run

data/bin/riemann-zookeeper

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+# Gathers zookeeper STATS and submits them to Riemann.
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::Zookeeper
+  include Riemann::Monitors
+  require 'socket'
+
+  opt :zookeeper_host, "Zookeeper hostname", :default => 'localhost'
+  opt :zookeeper_port, "Zookeeper port", :default => 2181
+
+  def tick
+    sock = TCPSocket.new(opts[:zookeeper_host], opts[:zookeeper_port])
+    sock.sync = true
+    sock.print("mntr")
+    sock.flush
+    
+
+    data = {}
+    while true
+      stats = sock.gets
+      
+      break if stats.nil?
+
+      m = stats.match /^(\w+)\t+(.*)/
+    
+      report(
+             :host => opts[ :zookeeper_host].dup,
+             :service => "zookeeper #{m[1]}",
+             :metric => m[2].to_f,
+             :state => 'ok',
+             :tags => ['zookeeper']
+             )
+    end      
+    sock.close
+  end
+end
+
+Riemann::Monitors::Zookeeper.run

data/data/statfields

@@ -0,0 +1,49 @@
+ppid
+pgrp
+session
+tty_nr
+tpgid
+flags
+minflt
+cminflt
+majflt
+cmajflt
+utime
+stime
+cutime
+cstime
+priority
+nice
+num_threads
+itrealvalue
+starttime
+vsize
+rss
+rsslim
+startcode
+endcode
+startstack
+kstkesp
+kstkeip
+signal
+blocked
+sigignore
+sigcatch
+wchan
+nswap
+cnswap
+exit_signal
+processor
+rt_priority
+policy
+delayacct_blkio_ticks
+guest_time
+cguest_time
+start_data
+end_data
+start_brk
+arg_start
+arg_end
+env_start
+env_end
+exit_code

data/lib/riemann-monitors/main.rb

@@ -0,0 +1,111 @@
+class Hash
+  def has_keys?(*rest)
+    rest.all? {|k| self.has_key?(k) }
+  end
+end
+
+module Riemann
+  module Monitors
+    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 :ssl, "Use SSL.", default: false
+        opt :ssl_ca_file, "SSL certificate authority cert", :default => File.join(Dir.home, ".config", "riemann-tools", "ca.crt")
+        opt :ssl_cert_file, "SSL client certificate public key", :default => File.join(Dir.home, ".config", "riemann-tools", "#{Socket.gethostname}.crt")
+        opt :ssl_key_file, "SSL client certificate private key", :default => File.join(Dir.home, ".config", "riemann-tools", "#{Socket.gethostname}.key")
+      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.to_sym,v]
+        end
+      end]
+    end
+
+    def report(event_hash)
+      event_hash[:tags] = (event_hash[:tags] || []) + (options[:tag] || [])
+      event_hash[:ttl] ||= (options[:ttl] || (options[:interval] * 2))
+      event_hash[:host] ||= options[:event_host]
+      event_hash.merge!(attributes)
+      riemann.add_event(event_hash)
+    end
+
+    def new_riemann_client
+      riemann_options = {
+        :server  => "#{options[:host]}:#{options[:port]}",
+        :connect_timeout => options[:timeout]
+      }
+      if options.has_keys?(:ssl_ca_file, :ssl_cert_file, :ssl_key_file) && options[:ssl]
+        # These are given to OpenSSL::SSL::SSLContext
+        riemann_options[:ssl] = {
+          ca_file: File.expand_path(options[:ssl_ca_file]),
+          cert:    OpenSSL::X509::Certificate.new(File.read(File.expand_path(options[:ssl_cert_file]))),
+          key:     OpenSSL::PKey::RSA.new(File.read(File.expand_path(options[:ssl_key_file]))),
+          verify_mode: OpenSSL::SSL::VERIFY_PEER,
+          ssl_version: :TLSv1_2
+        }
+      end
+      Riemann::Experiment::Client.new(riemann_options)
+    end
+
+    def riemann
+      @riemann ||= new_riemann_client
+    end
+    alias :r :riemann
+
+    def run
+      t0 = Time.now
+      loop do
+        begin
+          tick
+          riemann.send_message(ok: true)
+        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 tick
+    end
+  end
+end

data/lib/riemann-monitors/version.rb

@@ -0,0 +1,6 @@
+module Riemann::Monitors
+  VERSION = "0.0.1"
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 0
+  VERSION_TINY = 1
+end

data/lib/riemann-monitors.rb

@@ -0,0 +1,8 @@
+require 'riemann-ruby-experiments'
+require 'openssl'
+require 'trollop'
+require 'json'
+
+require_relative 'riemann-monitors/version'
+require_relative 'riemann-monitors/main'
+

data/project.yaml

@@ -0,0 +1,12 @@
+---
+name: "riemann-monitors"
+toplevel_module: Riemann::Monitors
+dependencies:
+  riemann-ruby-experiments: ">= 0.0.2"
+  trollop: ">= 1.16.2"
+  json: ">= 1.8.3"
+dev_dependencies:
+  rake: ">=10.3"
+  yard: "~> 0.8.7"
+  asciidoctor: "~> 1.5.2"
+