riemann-tools 1.0.0 → 1.2.0

data/bin/riemann-consul

@@ -1,107 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-# Reports service and node status to riemann
+Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-require 'socket'
-require 'net/http'
-require 'uri'
-require 'json'
-
-class Riemann::Tools::ConsulHealth
-  include Riemann::Tools
-
-  opt :consul_host, "Consul API Host (default to localhost)", :default => "localhost"
-  opt :consul_port, "Consul API Host (default to 8500)", :default => "8500"
-  opt :prefix, "prefix to use for all service names when reporting", :default => "consul "
-  opt :minimum_services_per_node, "minimum services per node (default: 0)", :default => 0
-
-  def initialize
-
-    @hostname = opts[:consul_host]
-    @prefix = opts[:prefix]
-    @minimum_services_per_node = opts[:minimum_services_per_node]
-    @underlying_ip = IPSocket.getaddress(@hostname)
-    @consul_leader_url = URI.parse("http://" + opts[:consul_host] + ":" + opts[:consul_port] + "/v1/status/leader")
-    @consul_services_url = URI.parse("http://" + opts[:consul_host] + ":" + opts[:consul_port] + "/v1/catalog/services")
-    @consul_nodes_url = URI.parse("http://" + opts[:consul_host] + ":" + opts[:consul_port] + "/v1/catalog/nodes")
-    @consul_health_url_prefix = "http://" + opts[:consul_host] + ":" + opts[:consul_port] + "/v1/health/service/"
-
-    @last_services_read = Hash.new
-
-  end
-
-  def alert(hostname, service, state, metric, description)
-
-    opts = {  :host => hostname,
-              :service => service.to_s,
-              :state => state.to_s,
-              :metric => metric,
-              :description => description }
-
-    report(opts)
-  end
-
-  def get(url)
-    Net::HTTP.get_response(url).body
-  end
-
-  def tick
-
-    leader = JSON.parse(get(@consul_leader_url))
-    leader_hostname = URI.parse("http://" + leader).hostname
-
-    if (leader_hostname == @underlying_ip)
-      nodes = JSON.parse(get(@consul_nodes_url))
-      services = JSON.parse(get(@consul_services_url))
-      services_by_nodes = Hash.new
-
-      for node in nodes
-        node_name = node["Node"]
-        services_by_nodes[node_name] = 0
-      end
-
-
-      # For every service
-      for service in services
-        service_name = service[0]
-        health_url = URI.parse(@consul_health_url_prefix + service_name)
-        health_nodes = JSON.parse(get(health_url))
-
-        totalCount = 0
-        okCount = 0
-
-        for node in health_nodes
-          hostname = node["Node"]["Node"]
-          ok = node["Checks"].all? {|check| check["Status"] == "passing"}
-          alert(hostname, "#{@prefix}#{service_name}", ok ? :ok : :critical, ok ? 1 : 0, JSON.generate(node))
-          totalCount += 1
-          okCount += ok ? 1 : 0
-
-          last_services_by_nodes = services_by_nodes[hostname].to_i
-          services_by_nodes[hostname] = last_services_by_nodes + 1
-        end
-
-        if (@last_services_read[service_name] != nil)
-          lastOk = @last_services_read[service_name]
-          if (lastOk != okCount)
-            alert("total", "#{@prefix}#{service_name}-count", okCount >= lastOk ? :ok : :critical, okCount, "Number of passing #{service_name} is: #{okCount}/#{totalCount}, Last time it was: #{lastOk}")
-          end
-        end
-
-        @last_services_read[service_name] = okCount
-
-      end
-
-      # For every node
-      for node,count in services_by_nodes
-        alert(node, "#{@prefix}total-services", (count >= @minimum_services_per_node) ? :ok : :critical, count, "#{count} services in the specified node")
-      end
-
-    end
-
-  end
-end
+require 'riemann/tools/consul_health'
 
 Riemann::Tools::ConsulHealth.run

data/bin/riemann-dir-files-count

@@ -1,56 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-# Gets the number of files present on a directory and submits it to riemann
+Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::DirFilesCount
-  include Riemann::Tools
-
-  opt :directory, "", :default => '/var/log'
-  opt :service_prefix, "The first part of the service name, before the directory path", :default => "dir-files-count"
-  opt :warning, "Dir files number warning threshold", :type => Integer
-  opt :critical, "Dir files number critical threshold", :type => Integer
-  opt :alert_on_missing, "Send a critical metric if the directory is missing?", :default => true
-
-  def initialize
-    @dir = opts.fetch(:directory)
-    @service_prefix = opts.fetch(:service_prefix)
-    @warning = opts.fetch(:warning, nil)
-    @critical = opts.fetch(:critical, nil)
-    @alert_on_missing = opts.fetch(:alert_on_missing)
-  end
-
-  def tick
-    if Dir.exists?(@dir)
-      metric = Dir.entries(@dir).size - 2
-      report(
-        :service => "#{@service_prefix} #{@dir}",
-        :metric => metric,
-        :state => state(metric),
-        :tags => ['dir_files_count']
-      )
-    elsif @alert_on_missing
-      report(
-        :service => "#{@service_prefix} #{@dir} missing",
-        :description => "#{@service_prefix} #{@dir} does not exist",
-        :metric => metric,
-        :state => 'critical',
-        :tags => ['dir_files_count']
-      )
-    end
-  end
-
-  def state(metric)
-    if @critical && metric > @critical
-      'critical'
-    elsif @warning && metric > @warning
-      'warning'
-    else
-      'ok'
-    end
-  end
-end
+require 'riemann/tools/dir_files_count'
 
 Riemann::Tools::DirFilesCount.run

data/bin/riemann-dir-space

@@ -1,56 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-# Gathers the space used by a directory and submits it to riemann
+Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::DirSpace
-  include Riemann::Tools
-
-  opt :directory, "", :default => '/var/log'
-  opt :service_prefix, "The first part of the service name, before the directory path", :default => "dir-space"
-  opt :warning, "Dir space warning threshold (in bytes)", :type => Integer
-  opt :critical, "Dir space critical threshold (in bytes)", :type => Integer
-  opt :alert_on_missing, "Send a critical metric if the directory is missing?", :default => true
-
-  def initialize
-    @dir = opts.fetch(:directory)
-    @service_prefix = opts.fetch(:service_prefix)
-    @warning = opts.fetch(:warning, nil)
-    @critical = opts.fetch(:critical, nil)
-    @alert_on_missing = opts.fetch(:alert_on_missing)
-  end
-
-  def tick
-    if Dir.exists?(@dir)
-      metric = `du '#{@dir}'`.lines.to_a.last.split("\t")[0].to_i
-      report(
-        :service => "#{@service_prefix} #{@dir}",
-        :metric => metric,
-        :state => state(metric),
-        :tags => ['dir_space']
-      )
-    elsif @alert_on_missing
-      report(
-        :service => "#{@service_prefix} #{@dir} missing",
-        :description => "#{@service_prefix} #{@dir} does not exist",
-        :metric => metric,
-        :state => 'critical',
-        :tags => ['dir_space']
-      )
-    end
-  end
-
-  def state(metric)
-    if @critical && metric > @critical
-      'critical'
-    elsif @warning && metric > @warning
-      'warning'
-    else
-      'ok'
-    end
-  end
-end
+require 'riemann/tools/dir_space'
 
 Riemann::Tools::DirSpace.run

data/bin/riemann-diskstats

@@ -1,96 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
-#
-require 'rubygems'
-require 'riemann/tools'
+# frozen_string_literal: true
 
-class Riemann::Tools::Diskstats
-  include Riemann::Tools
+Process.setproctitle($PROGRAM_NAME)
 
-  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|
-
-        if service =~ /io reqs$/
-          report(
-            :service => "diskstats " + service,
-            :metric => metric,
-            :state => "ok"
-          )
-        else
-          delta = metric - @old_state[service]
-
-          report(
-            :service => "diskstats " + service,
-            :metric => (delta.to_f / opts[:interval]),
-            :state => "ok"
-          )
-        end
-
-        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
+require 'riemann/tools/diskstats'
 
 Riemann::Tools::Diskstats.run

data/bin/riemann-fd

@@ -1,67 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-# Reports current file descriptor use to riemann.
-# By default reports the total system fd usage, can also report usage of individual processes
+Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
+require 'riemann/tools/fd'
 
-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
+Riemann::Tools::Fd.run

data/bin/riemann-freeswitch

@@ -1,120 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
+Process.setproctitle($PROGRAM_NAME)
 
-class Riemann::Tools::FreeSWITCH
-  include Riemann::Tools
+require 'riemann/tools/freeswitch'
 
-  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 exec_with_timeout(cmd, timeout)
-    pid = Process.spawn(cmd, {[:err,:out] => :close, :pgroup => true})
-    begin
-      Timeout.timeout(timeout) do
-        Process.waitpid(pid, 0)
-        $?.exitstatus == 0
-      end
-    rescue Timeout::Error
-      Process.kill(15, -Process.getpgid(pid))
-      puts "Killed pid: #{pid}"
-      false
-    end
-  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
-
-    # Determine how many conferences I have according to FreeSWITCH
-    fs_conferences = %x[fs_cli -x "conference list"| grep -Pco '^Conference'].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
-
-    fs_threads = fs_pid > 0 ? %x[ps huH p #{fs_pid} | wc -l].to_i : 0
-
-    # 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 conferences to riemann
-    if fs_conferences > @limits[:calls][:critical]
-      alert "FreeSWITCH current conferences", :critical, fs_conferences, "Number of conferences are #{fs_conferences}"
-    elsif fs_conferences > @limits[:calls][:warning]
-      alert "FreeSWITCH current conferences", :warning, fs_conferences, "Number of conferences are #{fs_conferences}"
-    else
-      alert "FreeSWITCH current conferences", :ok, fs_conferences, "Number of conferences are #{fs_conferences}"
-    end
-
-    # Submit threads to riemann
-    if fs_threads
-      alert "FreeSWITCH current threads", :ok, fs_threads, "Number of threads are #{fs_threads}"
-    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
-
-    # Submit CLI status to riemann using timeout in case it's unresponsive
-    if exec_with_timeout("fs_cli -x status", 2)
-      alert "FreeSWITCH CLI status", :ok, nil, "FreeSWITCH CLI status: responsive"
-    else
-      alert "FreeSWITCH CLI status", :critical, -1, "FreeSWITCH CLI status: not responding"
-    end
-
-  end
-end
-
-Riemann::Tools::FreeSWITCH.run
+Riemann::Tools::Freeswitch.run

data/bin/riemann-haproxy

@@ -1,59 +1,8 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-# Gathers haproxy CSV statistics and submits them to Riemann.
+Process.setproctitle($PROGRAM_NAME)
 
-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,
-            :tags    => ['haproxy']
-          )
-        end
-      end
-
-      report(
-        :host    => @uri.host,
-        :service => "#{ns} state",
-        :state   => (['UP', 'OPEN'].include?(row['status']) ? 'ok' : 'critical'),
-        :tags    => ['haproxy']
-      )
-    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
+require 'riemann/tools/haproxy'
 
 Riemann::Tools::Haproxy.run