riemann-tools 1.0.0 → 1.2.0

data/lib/riemann/tools/nginx_status.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Gathers nginx status stub statistics and submits them to Riemann.
+# See http://wiki.nginx.org/HttpStubStatusModule for configuring Nginx appropriately
+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

data/lib/riemann/tools/ntp.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Reports NTP stats to Riemann.
+module Riemann
+  module Tools
+    class Ntp
+      include Riemann::Tools
+
+      def initialize
+        @hostname = `hostname`.chomp
+        @ostype = `uname -s`.chomp.downcase
+        abort 'WARNING: macOS not explicitly supported. Exiting.' if @ostype == 'darwin'
+      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
+
+      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
+  end
+end

data/lib/riemann/tools/portcheck.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Checks for open tcp ports.
+# (c) Max Voit 2017
+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

data/lib/riemann/tools/proc.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Reports running process count to riemann.
+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: 65_536
+
+      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]
+
+        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 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
+          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
+      end
+
+      def tick
+        @check.call
+      end
+    end
+  end
+end

data/lib/riemann/tools/riemann_client_wrapper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require 'riemann/client'
+
+module Riemann
+  module Tools
+    class RiemannClientWrapper
+      include Singleton
+
+      def initialize
+        @client = nil
+      end
+
+      def configure(options)
+        return self unless @client.nil?
+
+        r = Riemann::Client.new(
+          host: options[:host],
+          port: options[:port],
+          timeout: options[:timeout],
+          ssl: options[:tls],
+          key_file: options[:tls_key],
+          cert_file: options[:tls_cert],
+          ca_file: options[:tls_ca_cert],
+          ssl_verify: options[:tls_verify],
+        )
+
+        @client = if options[:tcp] || options[:tls]
+                    r.tcp
+                  else
+                    r
+                  end
+        self
+      end
+
+      def <<(event)
+        @client << event
+      end
+    end
+  end
+end

data/lib/riemann/tools/uptime_parser.tab.rb

@@ -0,0 +1,323 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.6.0
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require 'strscan'
+
+module Riemann
+  module Tools
+    class UptimeParser < Racc::Parser
+
+module_eval(<<'...end uptime_parser.y/module_eval...', 'uptime_parser.y', 43)
+
+  def parse(text)
+    s = StringScanner.new(text)
+    @tokens = []
+
+    until s.eos? do
+      case
+      when s.scan(/\n/)              then # ignore
+      when s.scan(/\s+/)             then # ignore
+
+      when s.scan(/:/)               then @tokens << [':', s.matched]
+      when s.scan(/,/)               then @tokens << [',', s.matched]
+      when s.scan(/\d+[,.]\d+/)      then @tokens << [:FLOAT, s.matched.sub(',', '.').to_f]
+      when s.scan(/\d+/)             then @tokens << [:INTEGER, s.matched.to_i]
+      when s.scan(/AM/)              then @tokens << [:AM, s.matched]
+      when s.scan(/PM/)              then @tokens << [:PM, s.matched]
+      when s.scan(/up/)              then @tokens << [:UP, s.matched]
+      when s.scan(/days?/)           then @tokens << [:DAYS, s.matched]
+      when s.scan(/hrs?/)            then @tokens << [:HRS, s.matched]
+      when s.scan(/mins?/)           then @tokens << [:MINS, s.matched]
+      when s.scan(/secs?/)           then @tokens << [:SECS, s.matched]
+      when s.scan(/users?/)          then @tokens << [:USERS, s.matched]
+      when s.scan(/load averages?:/) then @tokens << [:LOAD_AVERAGES, s.matched]
+      else
+        raise s.rest
+      end
+    end
+
+    do_parse
+  end
+
+  def next_token
+    @tokens.shift
+  end
+...end uptime_parser.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    29,    30,    24,    26,    27,    28,    26,    27,    28,    40,
+    41,    25,    31,     3,    25,     4,     6,     7,     8,     9,
+    15,    16,    18,    23,    32,    33,    34,    35,    36,    38,
+    39,    42,    43,    44,    45 ]
+
+racc_action_check = [
+    16,    16,    15,    15,    15,    15,    23,    23,    23,    39,
+    39,    15,    16,     0,    23,     1,     2,     3,     4,     5,
+     6,     7,     9,    10,    17,    18,    24,    25,    31,    32,
+    38,    40,    41,    43,    44 ]
+
+racc_action_pointer = [
+     2,    15,    12,     3,    18,     6,     9,    10,   nil,    11,
+    12,   nil,   nil,   nil,   nil,    -3,    -2,    11,    16,   nil,
+   nil,   nil,   nil,     0,    13,    16,   nil,   nil,   nil,   nil,
+   nil,    17,    19,   nil,   nil,   nil,   nil,   nil,    18,    -3,
+    19,    20,   nil,    20,    22,   nil ]
+
+racc_action_default = [
+   -22,   -22,   -22,   -22,   -22,   -22,   -22,   -22,    46,   -22,
+   -22,   -10,   -11,   -12,   -13,   -22,    -2,   -22,   -22,    -6,
+    -7,    -8,    -9,   -22,   -22,   -22,   -16,   -17,   -18,    -3,
+    -4,   -22,   -22,   -19,   -14,   -15,    -5,    -1,   -22,   -22,
+   -22,   -22,   -20,   -22,   -22,   -21 ]
+
+racc_goto_table = [
+    11,    12,    13,    14,    19,    20,    21,    22,     1,     2,
+     5,    17,    37,    10 ]
+
+racc_goto_check = [
+     7,     8,     9,    10,     7,     8,     9,    10,     1,     2,
+     3,     4,     5,     6 ]
+
+racc_goto_pointer = [
+   nil,     8,     9,     8,     2,   -20,     7,    -6,    -5,    -4,
+    -3 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  6, 16, :_reduce_1,
+  3, 17, :_reduce_none,
+  4, 17, :_reduce_none,
+  4, 17, :_reduce_none,
+  5, 17, :_reduce_none,
+  3, 18, :_reduce_6,
+  3, 18, :_reduce_7,
+  3, 18, :_reduce_8,
+  3, 18, :_reduce_9,
+  2, 18, :_reduce_10,
+  2, 18, :_reduce_11,
+  2, 18, :_reduce_12,
+  2, 18, :_reduce_13,
+  3, 21, :_reduce_14,
+  3, 22, :_reduce_15,
+  2, 23, :_reduce_16,
+  2, 24, :_reduce_17,
+  2, 25, :_reduce_18,
+  2, 19, :_reduce_none,
+  4, 20, :_reduce_20,
+  6, 20, :_reduce_21 ]
+
+racc_reduce_n = 22
+
+racc_shift_n = 46
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :AM => 2,
+  :PM => 3,
+  :UP => 4,
+  :DAYS => 5,
+  :HRS => 6,
+  :MINS => 7,
+  :SECS => 8,
+  :USERS => 9,
+  :LOAD_AVERAGES => 10,
+  :INTEGER => 11,
+  :FLOAT => 12,
+  "," => 13,
+  ":" => 14 }
+
+racc_nt_base = 15
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "AM",
+  "PM",
+  "UP",
+  "DAYS",
+  "HRS",
+  "MINS",
+  "SECS",
+  "USERS",
+  "LOAD_AVERAGES",
+  "INTEGER",
+  "FLOAT",
+  "\",\"",
+  "\":\"",
+  "$start",
+  "target",
+  "time",
+  "uptime",
+  "users",
+  "load_averages",
+  "uptime_days",
+  "uptime_hr_min",
+  "uptime_hr",
+  "uptime_min",
+  "uptime_sec" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'uptime_parser.y', 4)
+  def _reduce_1(val, _values, result)
+     result = { uptime: val[1], users: val[3], load_averages: val[5] }
+    result
+  end
+.,.,
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+# reduce 4 omitted
+
+# reduce 5 omitted
+
+module_eval(<<'.,.,', 'uptime_parser.y', 11)
+  def _reduce_6(val, _values, result)
+     result = val[1] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 12)
+  def _reduce_7(val, _values, result)
+     result = val[1] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 13)
+  def _reduce_8(val, _values, result)
+     result = val[1] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 14)
+  def _reduce_9(val, _values, result)
+     result = val[1] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 15)
+  def _reduce_10(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 16)
+  def _reduce_11(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 17)
+  def _reduce_12(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 18)
+  def _reduce_13(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 20)
+  def _reduce_14(val, _values, result)
+     result = val[0] * 86400
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 22)
+  def _reduce_15(val, _values, result)
+     result = val[0] * 3600 + val[2] * 60
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 24)
+  def _reduce_16(val, _values, result)
+     result = val[0] * 3600
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 26)
+  def _reduce_17(val, _values, result)
+     result = val[0] * 60
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 28)
+  def _reduce_18(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+# reduce 19 omitted
+
+module_eval(<<'.,.,', 'uptime_parser.y', 32)
+  def _reduce_20(val, _values, result)
+     result = { 1 => val[1], 5 => val[2], 15 => val[3] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'uptime_parser.y', 33)
+  def _reduce_21(val, _values, result)
+     result = { 1 => val[1], 5 => val[3], 15 => val[5] }
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class UptimeParser
+  end   # module Tools
+end   # module Riemann

data/lib/riemann/tools/varnish.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'riemann/tools'
+
+# Reports varnish stats to Riemann.
+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