riemann-tools 1.1.1 → 1.2.0

data/lib/riemann/tools/dir_space.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Gathers the space used by a directory and submits it to riemann
+module Riemann
+  module Tools
+    class 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.exist?(@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
+  end
+end

data/lib/riemann/tools/diskstats.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+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

data/lib/riemann/tools/fd.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Reports current file descriptor use to riemann.
+# By default reports the total system fd usage, can also report usage of individual processes
+module Riemann
+  module Tools
+    class Fd
+      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

data/lib/riemann/tools/freeswitch.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'riemann/tools'
+
+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

data/lib/riemann/tools/haproxy.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Gathers haproxy CSV statistics and submits them to Riemann.
+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