riemann-tools 0.2.13 → 1.1.0

data/bin/riemann-apache-status

@@ -1,98 +1,113 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # 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
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
-
-class Riemann::Tools::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
+require File.expand_path('../lib/riemann/tools', __dir__)
+
+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)
 
-  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
 
-    response.slice! 'Scoreboard: '
-    response.each_char do |char|
-      results[char] += 1
-    end
-    Hash[results.map { |k, v| [@scoreboard_map[k], v] }]
-  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 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 get_connection
-    response = nil
-    begin
-      response = Net::HTTP.get(@uri)
-    rescue => 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?
 
-  def tick
-    unless (response = get_connection).nil?
-      response.each_line do |line|
-        metrics = Hash.new
+        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
+          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
-        report_metrics(metrics)
       end
     end
   end
-
 end
 
 Riemann::Tools::ApacheStatus.run

data/bin/riemann-bench

@@ -1,4 +1,7 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # Connects to a server (first arg) and populates it with a constant stream of
 # events for testing.
@@ -7,62 +10,65 @@ require 'rubygems'
 require 'riemann/client'
 require 'pp'
 
-class Riemann::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
+module Riemann
+  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
 
-  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
 
-    s = case m
-    when 0...0.75
-      'ok'
-    when 0.75...0.9
-      'warning'
-    when 0.9..1.0
-      'critical'
+      {
+        metric: m,
+        state: s,
+        host: state[:host],
+        service: state[:service],
+        description: "at #{Time.now}",
+      }
     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]))
+    def tick
+      #    pp @states
+      hosts.product(services).each do |id|
+        client << (states[id] = evolve(states[id]))
+      end
     end
-  end
 
-  def run
-    start
-    loop do
-      sleep 0.05
-      tick
+    def run
+      start
+      loop do
+        sleep 0.05
+        tick
+      end
     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
-      }
+    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

data/bin/riemann-cloudant

@@ -1,58 +1,63 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-# Gathers load balancer statistics from Cloudant.com (shared cluster) and submits them to Riemann.
+Process.setproctitle($PROGRAM_NAME)
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
+# Gathers load balancer statistics from Cloudant.com (shared cluster) and submits them to Riemann.
 
-class Riemann::Tools::Cloudant
-  include Riemann::Tools
-  require 'net/http'
-  require 'json'
+require File.expand_path('../lib/riemann/tools', __dir__)
 
-  opt :cloudant_username, "Cloudant username", :type => :string, :required => true
-  opt :cloudant_password, "Cloudant pasword", :type => :string, :required => true
+module Riemann
+  module Tools
+    class Cloudant
+      include Riemann::Tools
+      require 'net/http'
+      require 'json'
 
-  def tick
-    json = JSON.parse(get_json().body)
-    json.each do |node|
-      return if node['svname'] == 'BACKEND' # this is just a sum of all nodes.
+      opt :cloudant_username, 'Cloudant username', type: :string, required: true
+      opt :cloudant_password, 'Cloudant pasword', type: :string, required: true
 
-      ns = "cloudant #{node['pxname']}"
-      cluster_name = node['tracked'].split('.')[0] # ie: meritage.cloudant.com
+      def tick
+        json.each do |node|
+          break if node['svname'] == 'BACKEND' # this is just a sum of all nodes.
 
-      # report health of each node.
-      report(
-        :service => ns,
-        :state   => (node['status'] == 'UP' ? 'ok' : 'critical'),
-        :tags    => ['cloudant', cluster_name]
-      )
+          ns = "cloudant #{node['pxname']}"
+          cluster_name = node['tracked'].split('.')[0] # ie: meritage.cloudant.com
 
-      # report property->metric of each node.
-      node.each do |property, metric|
-        unless ['pxname', 'svname', 'status', 'tracked'].include?(property)
+          # report health of each node.
           report(
-            :host    => node['tracked'],
-            :service => "#{ns} #{property}",
-            :metric  => metric.to_f,
-            :state   => (node['status'] == 'UP' ? 'ok' : 'critical'),
-            :tags    => ['cloudant', cluster_name]
+            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
-
-   def get_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
-   end
-
 end
 
 Riemann::Tools::Cloudant.run

data/bin/riemann-consul

@@ -1,105 +1,112 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
+Process.setproctitle($PROGRAM_NAME)
 
 # Reports service and node status to riemann
 
-require File.expand_path('../../lib/riemann/tools', __FILE__)
+require File.expand_path('../lib/riemann/tools', __dir__)
 require 'socket'
 require 'net/http'
 require 'uri'
 require 'json'
 
-class Riemann::Tools::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 = Hash.new
-
-  end
+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)
+      def alert(hostname, service, state, metric, description)
+        opts = {
+          host: hostname,
+          service: service.to_s,
+          state: state.to_s,
+          metric: metric,
+          description: description,
+        }
 
-    opts = {  :host => hostname,
-              :service => service.to_s,
-              :state => state.to_s,
-              :metric => metric,
-              :description => description }
+        report(opts)
+      end
 
-    report(opts)
-  end
+      def get(url)
+        Net::HTTP.get_response(url).body
+      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
 
-  def tick
+        return unless leader_hostname == @underlying_ip
 
-    leader = JSON.parse(get(@consul_leader_url))
-    leader_hostname = URI.parse("http://" + leader).hostname
+        nodes = JSON.parse(get(@consul_nodes_url))
+        services = JSON.parse(get(@consul_services_url))
+        services_by_nodes = {}
 
-    if (leader_hostname == @underlying_ip)
-      nodes = JSON.parse(get(@consul_nodes_url))
-      services = JSON.parse(get(@consul_services_url))
-      services_by_nodes = Hash.new
+        nodes.each do |node|
+          node_name = node['Node']
+          services_by_nodes[node_name] = 0
+        end
 
-      for node in nodes
-        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
 
-      # For every service
-      for service in services
-        service_name = service[0]
-        health_url = URI.parse(@consul_health_url_prefix + service_name)
-        health_nodes = JSON.parse(get(health_url))
+          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
 
-        totalCount = 0
-        okCount = 0
+            last_services_by_nodes = services_by_nodes[hostname].to_i
+            services_by_nodes[hostname] = last_services_by_nodes + 1
+          end
 
-        for node in health_nodes
-          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))
-          totalCount += 1
-          okCount += ok ? 1 : 0
+          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_by_nodes = services_by_nodes[hostname].to_i
-          services_by_nodes[hostname] = last_services_by_nodes + 1
+          @last_services_read[service_name] = ok_count
         end
 
-        if (@last_services_read[service_name] != nil)
-          lastOk = @last_services_read[service_name]
-          if (lastOk != okCount)
-            alert("total", "#{@prefix}#{service_name}-count", okCount >= lastOk ? :ok : :critical, okCount, "Number of passing #{service_name} is: #{okCount}/#{totalCount}, Last time it was: #{lastOk}")
-          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
-
-        @last_services_read[service_name] = okCount
-
-      end
-
-      # For every node
-      for node,count in services_by_nodes
-        alert(node, "#{@prefix}total-services", (count >= @minimum_services_per_node) ? :ok : :critical, count, "#{count} services in the specified node")
       end
-
     end
-
   end
 end