riemann-tools 1.1.1 → 1.4.0

data/bin/riemann-diskstats

@@ -2,98 +2,7 @@
 # frozen_string_literal: true
 
 Process.setproctitle($PROGRAM_NAME)
-require 'rubygems'
-require 'riemann/tools'
 
-module Riemann
-  module Tools
-    class 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)/ }.each_with_object({}) do |line, s|
-          next unless line =~ /^(?:\s+\d+){2}\s+([\w\d\-]+) (.*)$/
-
-          dev = Regexp.last_match(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( # rubocop:disable Style/MultilineBlockChain
-            Regexp.last_match(2).split(/\s+/).map(&:to_i),
-          ).each do |service, value|
-            s[service] = value
-          end
-        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
-
-            next unless service =~ /io time$/
-
-            report(
-              service: "diskstats #{service.gsub(/time/, 'util')}",
-              metric: (delta.to_f / (opts[:interval] * 1000)),
-              state: 'ok',
-            )
-          end
-        end
-
-        @old_state = state
-      end
-    end
-  end
-end
+require 'riemann/tools/diskstats'
 
 Riemann::Tools::Diskstats.run

data/bin/riemann-fd

@@ -3,85 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Reports current file descriptor use to riemann.
-# By default reports the total system fd usage, can also report usage of individual processes
+require 'riemann/tools/fd'
 
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class 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
-        case ostype
-        when 'freebsd'
-          @fd = method :freebsd_fd
-        else
-          puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == 'linux'
-          @fd = method :linux_fd
-        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 freebsd_fd
-        sys_used = Integer(`sysctl -n kern.openfiles`)
-        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
-      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
-
-        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
-
-      def tick
-        @fd.call
-      end
-    end
-  end
-end
-
-Riemann::Tools::Health.run
+Riemann::Tools::Fd.run

data/bin/riemann-freeswitch

@@ -1,125 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'English'
-
 Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class 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)
-        Process.getpgid(pid)
-        false
-      rescue Errno::ESRCH
-        true
-      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, { %i[err out] => :close, :pgroup => true })
-        begin
-          Timeout.timeout(timeout) do
-            Process.waitpid(pid, 0)
-            $CHILD_STATUS.exitstatus.zero?
-          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 = `fs_cli -x "show calls count"| grep -Po '^\\d+'`.to_i
-
-        # Determine how many current channels I have according to FreeSWITCH
-        fs_channels = `fs_cli -x "show channels count"| grep -Po '^\\d+'`.to_i
-
-        # Determine how many conferences I have according to FreeSWITCH
-        fs_conferences = `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 StandardError
-          puts "Couldn't read pidfile: #{opts[:pid_file]}"
-          fs_pid = -666
-        end
-
-        fs_threads = fs_pid.positive? ? `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
-        alert 'FreeSWITCH current threads', :ok, fs_threads, "Number of threads are #{fs_threads}" if fs_threads
-
-        # 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
-  end
-end
+require 'riemann/tools/freeswitch'
 
-Riemann::Tools::FreeSWITCH.run
+Riemann::Tools::Freeswitch.run

data/bin/riemann-haproxy

@@ -3,63 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Gathers haproxy CSV statistics and submits them to Riemann.
-
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class 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.each do |row|
-          row = row.to_hash
-          ns  = "haproxy #{row['pxname']} #{row['svname']}"
-          row.each do |property, metric|
-            next if property.nil? || property == 'pxname' || property == 'svname'
-
-            report(
-              host: @uri.host,
-              service: "#{ns} #{property}",
-              metric: metric.to_f,
-              tags: ['haproxy'],
-            )
-          end
-
-          report(
-            host: @uri.host,
-            service: "#{ns} state",
-            state: (%w[UP OPEN].include?(row['status']) ? 'ok' : 'critical'),
-            tags: ['haproxy'],
-          )
-        end
-      end
-
-      def 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
-        CSV.parse(http.body.split('# ')[1], { headers: true })
-      end
-    end
-  end
-end
+require 'riemann/tools/haproxy'
 
 Riemann::Tools::Haproxy.run

data/bin/riemann-health

@@ -3,8 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Reports current CPU, disk, load average, and memory use to riemann.
-
 require 'riemann/tools/health'
 
 Riemann::Tools::Health.run

data/bin/riemann-kvminstance

@@ -3,26 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../lib/riemann/tools', __dir__)
+require 'riemann/tools/kvm'
 
-module Riemann
-  module Tools
-    class KVM
-      include Riemann::Tools
-
-      def tick
-        # determine how many instances I have according to libvirt
-        kvm_instances = `LANG=C virsh list | grep -c running`
-
-        # submit them to riemann
-        report(
-          service: 'KVM Running VMs',
-          metric: kvm_instances.to_i,
-          state: 'info',
-        )
-      end
-    end
-  end
-end
-
-Riemann::Tools::KVM.run
+Riemann::Tools::Kvm.run

data/bin/riemann-md

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
+
+require 'riemann/tools/md'
+
+Riemann::Tools::Md.run

data/bin/riemann-memcached

@@ -3,42 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Gathers memcached STATS and submits them to Riemann.
-
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class Memcached
-      include Riemann::Tools
-      require 'socket'
-
-      opt :memcached_host, 'Memcached hostname', default: 'localhost'
-      opt :memcached_port, 'Memcached port', default: 11_211
-
-      def tick
-        sock = TCPSocket.new(opts[:memcached_host], opts[:memcached_port])
-        sock.print("stats\r\n")
-        sock.flush
-        stats = sock.gets
-
-        loop do
-          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
-  end
-end
+require 'riemann/tools/memcached'
 
 Riemann::Tools::Memcached.run

data/bin/riemann-net

@@ -3,8 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Gathers network interface statistics and submits them to Riemann.
-
 require 'riemann/tools/net'
 
 Riemann::Tools::Net.run

data/bin/riemann-nginx-status

@@ -3,90 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Gathers nginx status stub statistics and submits them to Riemann.
-# See http://wiki.nginx.org/HttpStubStatusModule for configuring Nginx appropriately
-
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class NginxStatus
-      include Riemann::Tools
-      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.key? "#{key}_critical".to_sym
-          critical_threshold = opts["#{key}_critical".to_sym]
-          return 'critical' if critical_threshold.positive? && (value >= critical_threshold)
-        end
-
-        if opts.key? "#{key}_warning".to_sym
-          warning_threshold = opts["#{key}_warning".to_sym]
-          return 'warning' if warning_threshold.positive? && (value >= warning_threshold)
-        end
-
-        'ok'
-      end
-
-      def tick
-        response = nil
-        begin
-          response = Net::HTTP.get(@uri)
-        rescue StandardError => 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(&:to_i)
-
-        @keys.zip(values).each do |key, value|
-          report({
-                   service: "nginx #{key}",
-                   metric: value,
-                   state: state(key, value),
-                   tags: ['nginx'],
-                 })
-        end
-      end
-    end
-  end
-end
+require 'riemann/tools/nginx_status'
 
 Riemann::Tools::NginxStatus.run

data/bin/riemann-ntp

@@ -3,8 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Reports NTP stats to Riemann.
-
 require 'riemann/tools/ntp'
 
 Riemann::Tools::Ntp.run

data/bin/riemann-portcheck

@@ -3,49 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Checks for open tcp ports.
-# (c) Max Voit 2017
-
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class Portcheck
-      include Riemann::Tools
-      require 'socket'
-
-      opt :hostname, 'Host, defaults to localhost', default: `hostname`.chomp
-      opt :ports, "List of ports to check, e.g. '-r 80 443'", type: :ints
-
-      def initialize
-        @hostname = opts.fetch(:hostname)
-        @ports = opts.fetch(:ports)
-      end
-
-      def tick
-        @ports.each do |thisport|
-          # try opening tcp connection with 5s timeout;
-          # if this fails, the port is considered closed
-          portopen = begin
-            Socket.tcp(@hostname, thisport, connect_timeout: 5) { true }
-          rescue StandardError
-            false
-          end
-          state = if portopen
-                    'ok'
-                  else
-                    'critical'
-                  end
-          report(
-            host: @hostname.to_s,
-            service: "port #{thisport}",
-            state: state.to_s,
-            tags: ['portcheck'],
-          )
-        end
-      end
-    end
-  end
-end
+require 'riemann/tools/portcheck'
 
 Riemann::Tools::Portcheck.run