riemann-tools 1.1.1 → 1.4.0

data/bin/riemann-proc

@@ -3,113 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Reports running process count to riemann.
-
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-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
+require 'riemann/tools/proc'
 
 Riemann::Tools::Proc.run

data/bin/riemann-varnish

@@ -3,59 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Reports varnish stats to Riemann.
-
-require 'open3'
-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
+require 'riemann/tools/varnish'
 
 Riemann::Tools::Varnish.run

data/bin/riemann-wrapper

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
+
+def camelize(subject)
+  subject.gsub(%r{(^|[/_])[a-z]}) { |x| x.sub('/', '::').sub('_', '').upcase }
+end
+
+def underscore(subject)
+  subject.split(/(?=[A-Z])/).map(&:downcase).join('_').gsub('::_', '/')
+end
+
+def constantize(subject)
+  Object.const_get(subject)
+end
+
+def read_flags(argv)
+  res = []
+
+  while (arg = argv.shift)
+    break if arg == '--'
+
+    res << arg
+  end
+
+  res
+end
+
+def usage
+  warn <<~USAGE
+    usage: riemann-wrapper [common options] -- tool1 [tool1 options] [-- tool2 [tool2 options] ...]
+           riemann-wrapper /path/to/configuration/file.yml
+
+    Run multiple Riemann tools in a single process.  A single connection to
+    riemann is maintained and shared for all tools, the connection flags should
+    only be passed as common options.
+
+    Examples:
+      1. Run the fd, health and ntp tools with default options:
+
+         riemann-wrapper -- fd -- health -- ntp
+
+      2. Run the fd, health and ntp tools against a remote riemann server using
+         TCP and tagging each event with the name of the tool that produced it:
+
+         riemann-wrapper --host riemann.example.com --tcp -- \\
+                         fd     --tag=fd     -- \\
+                         health --tag=health -- \\
+                         ntp    --tag=ntp
+
+      3. Same as above example, but using a configuration file (more verbose but
+         easier to handle when running riemann-wrapper manually of managing it
+         with a Configuration Management system):
+
+         cat > config.yml << EOT
+         ---
+         options: --host riemann.example.com --tcp
+         tools:
+         - name: fd
+           options: --tag=fd
+         - name: health
+           options: --tag=health
+         - name: ntp
+           options: --tag=ntp
+         EOT
+         riemann-wrapper config.yml
+  USAGE
+  exit 1
+end
+
+usage if ARGV.empty?
+
+if ARGV.size == 1
+  unless File.readable?(ARGV[0])
+    warn "Cannot open file for reading: #{ARGV[0]}"
+    usage
+  end
+
+  require 'yaml'
+  config = YAML.safe_load(File.read(ARGV[0]))
+
+  commandline = config['options']
+  config['tools'].each { |tool| commandline << " -- #{tool['name']} #{tool['options']}" }
+
+  ARGV.replace(commandline.split)
+end
+
+argv = ARGV.dup
+
+common_argv = read_flags(argv)
+
+threads = []
+
+# Terminate the whole process is some thread fail
+Thread.abort_on_exception = true
+
+while argv.any?
+  tool = argv.shift
+  tool_argv = read_flags(argv)
+
+  require "riemann/tools/#{tool}"
+  tool_class = constantize(camelize("riemann/tools/#{tool}"))
+
+  ARGV.replace(common_argv + tool_argv)
+  instance = tool_class.new
+  # Force evaluation of options.  This rely on ARGV and needs to be done before
+  # we launch multiple threads which compete to read information from there.
+  instance.options
+  threads << Thread.new(instance, &:run)
+end
+
+threads.each(&:join)

data/bin/riemann-zookeeper

@@ -3,44 +3,6 @@
 
 Process.setproctitle($PROGRAM_NAME)
 
-# Gathers zookeeper STATS and submits them to Riemann.
-
-require File.expand_path('../lib/riemann/tools', __dir__)
-
-module Riemann
-  module Tools
-    class Zookeeper
-      include Riemann::Tools
-      require 'socket'
-
-      opt :zookeeper_host, 'Zookeeper hostname', default: 'localhost'
-      opt :zookeeper_port, 'Zookeeper port', default: 2181
-
-      def tick
-        sock = TCPSocket.new(opts[:zookeeper_host], opts[:zookeeper_port])
-        sock.sync = true
-        sock.print('mntr')
-        sock.flush
-
-        loop do
-          stats = sock.gets
-
-          break if stats.nil?
-
-          m = stats.match(/^(\w+)\t+(.*)/)
-
-          report(
-            host: opts[:zookeeper_host].dup,
-            service: "zookeeper #{m[1]}",
-            metric: m[2].to_f,
-            state: 'ok',
-            tags: ['zookeeper'],
-          )
-        end
-        sock.close
-      end
-    end
-  end
-end
+require 'riemann/tools/zookeeper'
 
 Riemann::Tools::Zookeeper.run

data/bin/riemann-zpool

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
+
+require 'riemann/tools/zpool'
+
+Riemann::Tools::Zpool.run

data/lib/riemann/tools/apache_status.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Collects Apache metrics and submits them to Riemann
+# More information can be found at http://httpd.apache.org/docs/2.4/mod/mod_status.html
+
+# Removes whitespace from 'Total Accesses' and 'Total kBytes' for output to graphite
+module Riemann
+  module Tools
+    class ApacheStatus
+      include Riemann::Tools
+      require 'net/http'
+      require 'uri'
+
+      opt :uri, 'Apache Server Status URI', default: 'http://localhost/server-status'
+
+      def initialize
+        @uri = "#{URI.parse(opts[:uri])}?auto"
+        # Sample Response with ExtendedStatus On
+        # Total Accesses: 20643
+        # Total kBytes: 36831
+        # CPULoad: .0180314
+        # Uptime: 43868
+        # ReqPerSec: .470571
+        # BytesPerSec: 859.737
+        # BytesPerReq: 1827.01
+        # BusyWorkers: 6
+        # IdleWorkers: 94
+        # Scoreboard: ___K_____K____________W_
+
+        @scoreboard_map = {
+          '_' => 'waiting',
+          'S' => 'starting',
+          'R' => 'reading',
+          'W' => 'sending',
+          'K' => 'keepalive',
+          'D' => 'dns',
+          'C' => 'closing',
+          'L' => 'logging',
+          'G' => 'graceful',
+          'I' => 'idle',
+          '.' => 'open',
+        }
+      end
+
+      def get_scoreboard_metrics(response)
+        results = Hash.new(0)
+
+        response.slice! 'Scoreboard: '
+        response.each_char do |char|
+          results[char] += 1
+        end
+        results.transform_keys { |k| @scoreboard_map[k] }
+      end
+
+      def report_metrics(metrics)
+        metrics.each do |k, v|
+          report(
+            service: "httpd #{k}",
+            metric: v.to_f,
+            state: 'ok',
+            tags: ['httpd'],
+          )
+        end
+      end
+
+      def connection
+        response = nil
+        begin
+          response = ::Net::HTTP.get(@uri)
+        rescue StandardError => e
+          report(
+            service: 'httpd health',
+            state: 'critical',
+            description: "Httpd connection error: #{e.class} - #{e.message}",
+            tags: ['httpd'],
+          )
+        else
+          report(
+            service: 'httpd health',
+            state: 'ok',
+            description: 'Httpd connection status ok',
+            tags: ['httpd'],
+          )
+        end
+        response
+      end
+
+      def tick
+        return if (response = connection).nil?
+
+        response.each_line do |line|
+          metrics = {}
+
+          if line =~ /Scoreboard/
+            metrics = get_scoreboard_metrics(line.strip)
+          else
+            key, value = line.strip.split(':')
+            metrics[key.gsub(/\s/, '')] = value
+          end
+          report_metrics(metrics)
+        end
+      end
+    end
+  end
+end

data/lib/riemann/tools/bench.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'riemann/client'
+require 'pp'
+
+# Connects to a server (first arg) and populates it with a constant stream of
+# events for testing.
+module Riemann
+  module Tools
+    class Bench
+      attr_accessor :client, :hosts, :services, :states
+
+      def initialize
+        @hosts = [nil] + (0...10).map { |i| "host#{i}" }
+        @hosts = %w[a b c d e f g h i j]
+        @services = %w[test1 test2 test3 foo bar baz xyzzy attack cat treat]
+        @states = {}
+        @client = Riemann::Client.new(host: (ARGV.first || 'localhost'))
+      end
+
+      def evolve(state)
+        m = state[:metric] + (rand - 0.5) * 0.1
+        m = [[0, m].max, 1].min
+
+        s = case m
+            when 0...0.75
+              'ok'
+            when 0.75...0.9
+              'warning'
+            when 0.9..1.0
+              'critical'
+            end
+
+        {
+          metric: m,
+          state: s,
+          host: state[:host],
+          service: state[:service],
+          description: "at #{Time.now}",
+        }
+      end
+
+      def tick
+        #    pp @states
+        hosts.product(services).each do |id|
+          client << (states[id] = evolve(states[id]))
+        end
+      end
+
+      def run
+        start
+        loop do
+          sleep 0.05
+          tick
+        end
+      end
+
+      def start
+        hosts.product(services).each do |host, service|
+          states[[host, service]] = {
+            metric: 0.5,
+            state: 'ok',
+            description: 'Starting up',
+            host: host,
+            service: service,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/riemann/tools/cloudant.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+
+# Gathers load balancer statistics from Cloudant.com (shared cluster) and submits them to Riemann.
+module Riemann
+  module Tools
+    class Cloudant
+      include Riemann::Tools
+      require 'net/http'
+      require 'json'
+
+      opt :cloudant_username, 'Cloudant username', type: :string, required: true
+      opt :cloudant_password, 'Cloudant pasword', type: :string, required: true
+
+      def tick
+        json.each do |node|
+          break if node['svname'] == 'BACKEND' # this is just a sum of all nodes.
+
+          ns = "cloudant #{node['pxname']}"
+          cluster_name = node['tracked'].split('.')[0] # ie: meritage.cloudant.com
+
+          # report health of each node.
+          report(
+            service: ns,
+            state: (node['status'] == 'UP' ? 'ok' : 'critical'),
+            tags: ['cloudant', cluster_name],
+          )
+
+          # report property->metric of each node.
+          node.each do |property, metric|
+            next if %w[pxname svname status tracked].include?(property)
+
+            report(
+              host: node['tracked'],
+              service: "#{ns} #{property}",
+              metric: metric.to_f,
+              state: (node['status'] == 'UP' ? 'ok' : 'critical'),
+              tags: ['cloudant', cluster_name],
+            )
+          end
+        end
+      end
+
+      def json
+        http = ::Net::HTTP.new('cloudant.com', 443)
+        http.use_ssl = true
+        http.start do |h|
+          get = ::Net::HTTP::Get.new('/api/load_balancer')
+          get.basic_auth opts[:cloudant_username], opts[:cloudant_password]
+          h.request get
+        end
+        JSON.parse(http.boby)
+      end
+    end
+  end
+end

data/lib/riemann/tools/consul_health.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'riemann/tools'
+require 'socket'
+require 'net/http'
+require 'uri'
+require 'json'
+
+# Reports service and node status to riemann
+module Riemann
+  module Tools
+    class ConsulHealth
+      include Riemann::Tools
+
+      opt :consul_host, 'Consul API Host (default to localhost)', default: 'localhost'
+      opt :consul_port, 'Consul API Host (default to 8500)', default: '8500'
+      opt :prefix, 'prefix to use for all service names when reporting', default: 'consul '
+      opt :minimum_services_per_node, 'minimum services per node (default: 0)', default: 0
+
+      def initialize
+        @hostname = opts[:consul_host]
+        @prefix = opts[:prefix]
+        @minimum_services_per_node = opts[:minimum_services_per_node]
+        @underlying_ip = IPSocket.getaddress(@hostname)
+        @consul_leader_url = URI.parse("http://#{opts[:consul_host]}:#{opts[:consul_port]}/v1/status/leader")
+        @consul_services_url = URI.parse("http://#{opts[:consul_host]}:#{opts[:consul_port]}/v1/catalog/services")
+        @consul_nodes_url = URI.parse("http://#{opts[:consul_host]}:#{opts[:consul_port]}/v1/catalog/nodes")
+        @consul_health_url_prefix = "http://#{opts[:consul_host]}:#{opts[:consul_port]}/v1/health/service/"
+
+        @last_services_read = {}
+      end
+
+      def alert(hostname, service, state, metric, description)
+        opts = {
+          host: hostname,
+          service: service.to_s,
+          state: state.to_s,
+          metric: metric,
+          description: description,
+        }
+
+        report(opts)
+      end
+
+      def get(url)
+        ::Net::HTTP.get_response(url).body
+      end
+
+      def tick
+        leader = JSON.parse(get(@consul_leader_url))
+        leader_hostname = URI.parse("http://#{leader}").hostname
+
+        return unless leader_hostname == @underlying_ip
+
+        nodes = JSON.parse(get(@consul_nodes_url))
+        services = JSON.parse(get(@consul_services_url))
+        services_by_nodes = {}
+
+        nodes.each do |node|
+          node_name = node['Node']
+          services_by_nodes[node_name] = 0
+        end
+
+        # For every service
+        services.each do |service|
+          service_name = service[0]
+          health_url = URI.parse(@consul_health_url_prefix + service_name)
+          health_nodes = JSON.parse(get(health_url))
+
+          total_count = 0
+          ok_count = 0
+
+          health_nodes.each do |node|
+            hostname = node['Node']['Node']
+            ok = node['Checks'].all? { |check| check['Status'] == 'passing' }
+            alert(hostname, "#{@prefix}#{service_name}", ok ? :ok : :critical, ok ? 1 : 0, JSON.generate(node))
+            total_count += 1
+            ok_count += ok ? 1 : 0
+
+            last_services_by_nodes = services_by_nodes[hostname].to_i
+            services_by_nodes[hostname] = last_services_by_nodes + 1
+          end
+
+          unless @last_services_read[service_name].nil?
+            last_ok = @last_services_read[service_name]
+            if last_ok != ok_count
+              alert(
+                'total', "#{@prefix}#{service_name}-count", ok_count >= last_ok ? :ok : :critical, ok_count,
+                "Number of passing #{service_name} is: #{ok_count}/#{total_count}, Last time it was: #{last_ok}",
+              )
+            end
+          end
+
+          @last_services_read[service_name] = ok_count
+        end
+
+        # For every node
+        services_by_nodes.each do |node, count|
+          alert(
+            node, "#{@prefix}total-services", count >= @minimum_services_per_node ? :ok : :critical, count,
+            "#{count} services in the specified node",
+          )
+        end
+      end
+    end
+  end
+end