riemann-tools 1.0.0 → 1.1.0

data/bin/riemann-nginx-status

@@ -1,83 +1,90 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+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', __FILE__)
-
-class Riemann::Tools::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
+require File.expand_path('../lib/riemann/tools', __dir__)
 
-  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
+module Riemann
+  module Tools
+    class NginxStatus
+      include Riemann::Tools
+      require 'net/http'
+      require 'uri'
 
-    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
+      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
 
-    return 'ok'
-  end
+      def initialize
+        @uri = URI.parse(opts[:uri])
 
-  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
+        # 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?
+        return if response.nil?
 
-    report(
-      :service => "nginx health",
-      :state => "ok",
-      :description => "Nginx status connection ok"
-    )
+        report(
+          service: 'nginx health',
+          state: 'ok',
+          description: 'Nginx status connection ok',
+        )
 
-    values = @re.match(response).to_a[1,7].map { |v| v.to_i }
+        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']
-      })
+        @keys.zip(values).each do |key, value|
+          report({
+                   service: "nginx #{key}",
+                   metric: value,
+                   state: state(key, value),
+                   tags: ['nginx'],
+                 })
+        end
+      end
     end
   end
 end

data/bin/riemann-ntp

@@ -1,39 +1,10 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
 
-# Reports NTP stats to Riemann.
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Ntp
-  include Riemann::Tools
+Process.setproctitle($PROGRAM_NAME)
 
-  def initialize
-    @hostname = `hostname`.chomp
-  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
+# Reports NTP stats to Riemann.
 
-  def send(type,metric)
-      report(
-        :host => @hostname,
-        :service => "ntp peer #{@ntp_host} #{type}",
-        :metric => metric.to_f,
-        :state => "ok",
-        :description => "ntp peer #{@ntp_host} #{type}",
-        :tags => ["ntp"]
-      )
-  end
-end
+require 'riemann/tools/ntp'
 
 Riemann::Tools::Ntp.run

data/bin/riemann-portcheck

@@ -1,42 +1,51 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # Checks for open tcp ports.
 # (c) Max Voit 2017
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::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
-    for thisport in @ports
-	  # try opening tcp connection with 5s timeout;
-      # if this fails, the port is considered closed
-      portopen = Socket.tcp(@hostname, thisport, connect_timeout: 5) { true } rescue false
-        if portopen
-          state = "ok"
-        else
-          state = "critical"
+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
-      report(
-        :host    => "#{@hostname}",
-        :service => "port #{thisport}",
-        :state   => "#{state}",
-        :tags    => ["portcheck"]
-      )
+      end
     end
   end
-
 end
 
 Riemann::Tools::Portcheck.run

data/bin/riemann-proc

@@ -1,108 +1,114 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # Reports running process count to riemann.
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
+require File.expand_path('../lib/riemann/tools', __dir__)
 
-class Riemann::Tools::Proc
-  include Riemann::Tools
+module Riemann
+  module Tools
+    class Proc
+      include Riemann::Tools
 
-  opt :proc_regex, "regular expression that matches the process to be monitored", type: :string, :default => ".*"
-  opt :proc_min_critical, "running process count minimum", :default => 0
-  opt :proc_max_critical, "running process count maximum", :default => 65536
+      opt :proc_regex, 'regular expression that matches the process to be monitored', type: :string, default: '.*'
+      opt :proc_min_critical, 'running process count minimum', default: 0
+      opt :proc_max_critical, 'running process count maximum', default: 65_536
 
-  def initialize
-    @limits = { :critical => { :min => opts[:proc_min_critical], :max => opts[:proc_max_critical] } }
+      def initialize
+        @limits = { critical: { min: opts[:proc_min_critical], max: opts[:proc_max_critical] } }
 
-    abort "FATAL: specify a process regular expression, see --help for usage" unless opts[:proc_regex]
+        abort 'FATAL: specify a process regular expression, see --help for usage' unless opts[:proc_regex]
 
-    ostype = `uname -s`.chomp.downcase
-    puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == "linux"
-    @check = method :linux_proc
-  end
+        ostype = `uname -s`.chomp.downcase
+        puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == 'linux'
+        @check = method :linux_proc
+      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_proc
-    process = opts[:proc_regex]
-    found = `ps axo pid=,rss=,vsize=,state=,cputime=,lstart=,command= | grep '#{process}' | grep -v grep | grep -v riemann-proc`
-    running = found.count("\n")
-    if running > @limits[:critical][:max] or running < @limits[:critical][:min]
-      alert "proc count/#{process}", :critical, running, "process #{process} is running #{running} instances.\n"
-    else
-      alert "proc count/#{process}", :ok, running, "process #{process} is running #{running} instances.\n"
-    end
-    # Iterate on all the lines and create an entry for the following metrics:
-    #
-    # process/<pid>-<start-time>/rss
-    # process/<pid>-<start-time>/vsize
-    # process/<pid>-<start-time>/running
-    # process/<pid>-<start-time>/cputime
-    #
-    # description should contain the command itself.
-    # value should be either process RSS, VSIZE, or 1 if running
-    # state is always unknown for the moment
-    #
-    ps_regex = /([0-9]+)[ ]+([0-9]+)[ ]+([0-9]+)[ ]+([A-Z])[ ]+([0-9:.]+)[ ]+[A-Za-z]{3}[ ]+([A-Za-z]{3}[ ]{1,2}[0-9]+ [0-9:]+ [0-9]+)[ ]+(.*)/
-    found.each_line do |line|
-      m = ps_regex.match(line)
-      if not m.nil?
-        pid, rss, vsize, state, cputime, start, command = m.captures
-        start_s = DateTime.parse(start, "Mmm DD HH:MM:ss YYYY").to_time.to_i
-        cputime_s = DateTime.parse(cputime, "%H:%M:%S")
-        cputime_seconds = (cputime_s.hour * 3600) + (cputime_s.minute * 60) + cputime_s.second
-        running = 0
-        case state[0]
-        when "R"
-          state_s = "ok"
-          running = 1
-        when "S"
-          state_s = "ok"
-        when "I"
-          state_s = "warning"
-        when "T", "U", "Z"
-          state_s = "critical"
+      def linux_proc
+        process = opts[:proc_regex]
+        found = `ps axo pid=,rss=,vsize=,state=,cputime=,lstart=,command= | grep '#{process}' | grep -v grep | grep -v riemann-proc`
+        running = found.count("\n")
+        if (running > @limits[:critical][:max]) || (running < @limits[:critical][:min])
+          alert "proc count/#{process}", :critical, running, "process #{process} is running #{running} instances.\n"
         else
-          state_s = "unknown"
+          alert "proc count/#{process}", :ok, running, "process #{process} is running #{running} instances.\n"
+        end
+        # Iterate on all the lines and create an entry for the following metrics:
+        #
+        # process/<pid>-<start-time>/rss
+        # process/<pid>-<start-time>/vsize
+        # process/<pid>-<start-time>/running
+        # process/<pid>-<start-time>/cputime
+        #
+        # description should contain the command itself.
+        # value should be either process RSS, VSIZE, or 1 if running
+        # state is always unknown for the moment
+        #
+        ps_regex = /([0-9]+) +([0-9]+) +([0-9]+) +([A-Z]) +([0-9:.]+) +[A-Za-z]{3} +([A-Za-z]{3} {1,2}[0-9]+ [0-9:]+ [0-9]+) +(.*)/
+        found.each_line do |line|
+          m = ps_regex.match(line)
+          next if m.nil?
+
+          pid, rss, vsize, state, cputime, start, command = m.captures
+          start_s = DateTime.parse(start, 'Mmm DD HH:MM:ss YYYY').to_time.to_i
+          cputime_s = DateTime.parse(cputime, '%H:%M:%S')
+          cputime_seconds = (cputime_s.hour * 3600) + (cputime_s.minute * 60) + cputime_s.second
+          running = 0
+          case state[0]
+          when 'R'
+            state_s = 'ok'
+            running = 1
+          when 'S'
+            state_s = 'ok'
+          when 'I'
+            state_s = 'warning'
+          when 'T', 'U', 'Z'
+            state_s = 'critical'
+          else
+            state_s = 'unknown'
+          end
+          report(
+            service: "proc #{pid}-#{start_s}/rss",
+            state: state_s.to_s,
+            metric: rss.to_f,
+            description: command,
+          )
+          report(
+            service: "proc #{pid}-#{start_s}/vsize",
+            state: state_s.to_s,
+            metric: vsize.to_f,
+            description: command,
+          )
+          report(
+            service: "proc #{pid}-#{start_s}/running",
+            state: state_s.to_s,
+            metric: running.to_f,
+            description: command,
+          )
+          report(
+            service: "proc #{pid}-#{start_s}/cputime",
+            state: state_s.to_s,
+            metric: cputime_seconds,
+            description: command,
+          )
         end
-        report(
-          :service => "proc #{pid}-#{start_s}/rss",
-          :state => state_s.to_s,
-          :metric => rss.to_f,
-          :description => command,
-        )
-        report(
-          :service => "proc #{pid}-#{start_s}/vsize",
-          :state => state_s.to_s,
-          :metric => vsize.to_f,
-          :description => command,
-        )
-        report(
-          :service => "proc #{pid}-#{start_s}/running",
-          :state => state_s.to_s,
-          :metric => running.to_f,
-          :description => command,
-        )
-        report(
-          :service => "proc #{pid}-#{start_s}/cputime",
-          :state => state_s.to_s,
-          :metric => cputime_seconds,
-          :description => command,
-        )
       end
-    end
-  end
 
-  def tick
-    @check.call
+      def tick
+        @check.call
+      end
+    end
   end
 end
 

data/bin/riemann-varnish

@@ -1,53 +1,59 @@
 #!/usr/bin/env ruby
-Process.setproctitle($0)
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # Reports varnish stats to Riemann.
 
 require 'open3'
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Varnish
-  include Riemann::Tools
-
-  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"]
-            )
+require File.expand_path('../lib/riemann/tools', __dir__)
+
+module Riemann
+  module Tools
+    class Varnish
+      include Riemann::Tools
+
+      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
+
+        @vstats = if @ver >= 4
+                    ['MAIN.sess_conn',
+                     'MAIN.sess_drop ',
+                     'MAIN.client_req',
+                     'MAIN.cache_hit',
+                     'MAIN.cache_miss',]
+                  else
+                    %w[client_conn
+                       client_drop
+                       client_req
+                       cache_hit
+                       cache_miss]
+                  end
+      end
+
+      def tick
+        stats = if @ver >= 4
+                  `varnishstat -1 -f #{@vstats.join(' -f ')}`
+                else
+                  `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..].join(' ').to_s,
+            tags: ['varnish'],
+          )
+        end
+      end
     end
   end
 end