riemann-tools 0.2.14 → 1.1.1

data/bin/riemann-dir-files-count

@@ -1,53 +1,60 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-# Gets the number of files present on a directory and submits it to riemann
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::DirFilesCount
-  include Riemann::Tools
+Process.setproctitle($PROGRAM_NAME)
 
-  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
+# Gets the number of files present on a directory and submits it to riemann
 
-  def state(metric)
-    if @critical && metric > @critical
-      'critical'
-    elsif @warning && metric > @warning
-      'warning'
-    else
-      'ok'
+require File.expand_path('../lib/riemann/tools', __dir__)
+
+module Riemann
+  module Tools
+    class 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.exist?(@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
   end
 end

data/bin/riemann-dir-space

@@ -1,53 +1,60 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-# Gathers the space used by a directory and submits it to riemann
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::DirSpace
-  include Riemann::Tools
+Process.setproctitle($PROGRAM_NAME)
 
-  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
+# Gathers the space used by a directory and submits it to riemann
 
-  def state(metric)
-    if @critical && metric > @critical
-      'critical'
-    elsif @warning && metric > @warning
-      'warning'
-    else
-      'ok'
+require File.expand_path('../lib/riemann/tools', __dir__)
+
+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/bin/riemann-diskstats

@@ -1,94 +1,98 @@
 #!/usr/bin/env ruby
-#
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 require 'rubygems'
 require 'riemann/tools'
 
-class Riemann::Tools::Diskstats
-  include 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
+      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 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
+      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
-      end
 
-      s
-    end
+        # Filter interfaces
+        if (is = opts[:devices])
+          state = state.select do |service, _value|
+            is.include? service.split(' ').first
+          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
 
-    if ign = opts[:ignore_devices]
-      state = state.reject do |service, value|
-        ign.include? service.split(' ').first
+        state
       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"
-          )
+      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
 
-        if service =~ /io time$/
-          report(:service => "diskstats " + service.gsub(/time/, 'util'),
-                 :metric => (delta.to_f / (opts[:interval]*1000)),
-                 :state => "ok")
-        end
+        @old_state = state
       end
     end
-
-    @old_state = state
   end
 end
 

data/bin/riemann-fd

@@ -1,65 +1,86 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+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 File.expand_path('../../lib/riemann/tools', __FILE__)
+require File.expand_path('../lib/riemann/tools', __dir__)
 
-class Riemann::Tools::Health
-  include Riemann::Tools
+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
+      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 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 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
+      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
 
-    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"
+      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 #{name} #{process}", :ok, used, "process #{name} #{process} is using #{used} fds"
+          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
-    end
-  end
 
-  def tick
-    @fd.call
+      def tick
+        @fd.call
+      end
+    end
   end
 end