riemann-tools 0.2.14 → 1.1.1

data/bin/riemann-kvminstance

@@ -1,21 +1,27 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
+Process.setproctitle($PROGRAM_NAME)
 
-class Riemann::Tools::KVM
-  include Riemann::Tools
+require File.expand_path('../lib/riemann/tools', __dir__)
 
-  def tick
+module Riemann
+  module Tools
+    class KVM
+      include Riemann::Tools
 
-  #determine how many instances I have according to libvirt
-  kvm_instances = %x[LANG=C virsh list | grep -c running]
+      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"
-       )
+        # submit them to riemann
+        report(
+          service: 'KVM Running VMs',
+          metric: kvm_instances.to_i,
+          state: 'info',
+        )
+      end
+    end
   end
 end
 

data/bin/riemann-memcached

@@ -1,36 +1,43 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # Gathers memcached STATS and submits them to Riemann.
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Memcached
-  include Riemann::Tools
-  require 'socket'
-
-  opt :memcached_host, "Memcached hostname", :default => 'localhost'
-  opt :memcached_port, "Memcached port", :default => 11211
-
-  def tick
-    sock = TCPSocket.new(opts[:memcached_host], opts[:memcached_port])
-    sock.print("stats\r\n")
-    sock.flush
-    stats = sock.gets
-
-    data = {}
-    while true
-      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']
-             )
+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
-    sock.close
   end
 end
 

data/bin/riemann-net

@@ -1,109 +1,10 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-# Gathers network interface statistics and submits them to Riemann.
-
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::Net
-  include Riemann::Tools
-
-  opt :interfaces, "Interfaces to monitor", :type => :strings, :default => nil
-  opt :ignore_interfaces, "Interfaces to ignore", :type => :strings, :default =>['lo']
-
-  def initialize
-    @old_state = nil
-    @interfaces = opts[:interfaces].map(&:dup) if opts[:interfaces]
-    @ignore_interfaces = opts[:ignore_interfaces].map(&:dup)
-  end
-
-  def state
-    f = File.read('/proc/net/dev')
-    state = f.split("\n").inject({}) do |s, line|
-      if line =~ /\s*(\w+?):\s*([\s\d]+)\s*/
-        iface = $1
-
-        ['rx bytes',
-        'rx packets',
-        'rx errs',
-        'rx drop',
-        'rx fifo',
-        'rx frame',
-        'rx compressed',
-        'rx multicast',
-        'tx bytes',
-        'tx packets',
-        'tx errs',
-        'tx drops',
-        'tx fifo',
-        'tx colls',
-        'tx carrier',
-        'tx compressed'].map do |service|
-          "#{iface} #{service}"
-        end.zip(
-          $2.split(/\s+/).map { |str| str.to_i }
-        ).each do |service, value|
-          s[service] = value
-        end
-      end
-      
-      s
-    end
+Process.setproctitle($PROGRAM_NAME)
 
-    # Filter interfaces
-    if is = @interfaces
-      state = state.select do |service, value|
-        is.include? service.split(' ').first
-      end
-    end
-
-    state = state.reject do |service, value|
-      @ignore_interfaces.include? service.split(' ').first
-    end
-
-    state
-  end
-  
-  def tick
-    state = self.state
-
-    if @old_state
-      # Report services from `@old_state` that don't exist in `state` as expired
-      @old_state.reject { |k| state.has_key?(k) }.each do |service, metric|
-        report(:service => service.dup, :state => 'expired')
-      end
-
-      # Report delta for services that have values in both `@old_state` and `state`
-      state.each do |service, metric|
-        next unless @old_state.has_key?(service)
-
-        delta = metric - @old_state[service]
-        svc_state = case service
-          when /drop$/
-            if delta > 0
-              'warning'
-            else
-              'ok'
-            end
-          when /errs$/
-            if delta > 0
-              'warning'
-            else
-              'ok'
-            end
-          else
-            'ok'
-          end
+# Gathers network interface statistics and submits them to Riemann.
 
-        report(
-          :service => service.dup,
-          :metric => (delta.to_f / opts[:interval]),
-          :state => svc_state
-        )
-      end
-    end
+require 'riemann/tools/net'
 
-    @old_state = state
-  end
-end
-  
 Riemann::Tools::Net.run

data/bin/riemann-nginx-status

@@ -1,82 +1,90 @@
 #!/usr/bin/env ruby
+# 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,38 +1,10 @@
 #!/usr/bin/env ruby
+# 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,41 +1,51 @@
 #!/usr/bin/env ruby
+# 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