riemann-monitors 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce2a724b0e9f58a3428fb402dc313167eefbd0b5
+  data.tar.gz: ae4f41b34dbf278b6ab92c0dd89c2f6e5cd5ccf6
+SHA512:
+  metadata.gz: 3972340ad48aa5142ba96583d98edc771881db39bd48e0f747bfbfff473003975fe60638b0de8acbf5f7ab51508e7d3dba2d7214ad857c90b9156a4a63112f1c
+  data.tar.gz: a862891b8187f2947d4e490eb1c0b69db6c44a108648470a454edb0266e3a6c6bcbe5f37322993ed5bbaa1c288c3618058e6fb7aea368684c09aec840101afd3

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Kyle Kingsbury
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.adoc

@@ -0,0 +1,75 @@
+= riemann-monitors
+Chris Riddoch <riddochc@gmail.com>
+:language: ruby
+:homepage: https://github.com/riddochc/riemann-monitors
+:revnumber: 0.0.1
+:revdate: 2016-05-29
+
+== Description
+
+Tiny programs to submit events to Riemann.
+
+This is a polite fork of riemann-tools, using my riemann-ruby-experiments gem
+instead of riemann-ruby-client.  As a result, events can be batched together
+to be sent in one message to a Riemann server.  Additionally, more control
+over the TCP socket options is given, and UDP isn't supported (yet?), because
+this gem primarily uses net_ruby_client.
+
+== Requirements
+
+* Ruby 2.0 or higher (currently only tested on 2.3)
+* A riemann server to talk to
+
+== Installation
+
+  gem install riemann-monitors
+
+== Use
+
+  riemann-health
+
+This defaults to connecting to a Riemann server listening on 127.0.0.1, TCP port 5555.
+
+== Riemann-tools programs
+
+This repository contains a number of different programs, mostly identical to those
+in `riemann-tools`.
+
+riemann-httpstatus:: Monitoring results of periodic HTTP requests.
+riemann-apache-status:: Apache monitoring.
+riemann-dir-files-count:: File counts.
+riemann-freeswitch:: FreeSwitch monitoring.
+riemann-memcached:: Monitor Memcache.
+riemann-proc:: Linux process monitoring.
+riemann-bench:: Load testing for Riemann.
+riemann-dir-space:: Directory space monitoring.
+riemann-haproxy:: Monitor HAProxy.
+riemann-net:: Network interface monitoring.
+riemann-varnish:: Monitor Varnish.
+riemann-cloudant:: Cloudant monitoring.
+riemann-diskstats:: Disk statistics.
+riemann-health:: General CPU, memory, disk and load monitoring.
+riemann-nginx-status:: Monitor Nginx.
+riemann-zookeeper:: Monitor Zookeeper.
+riemann-consul:: Monitor Consul.
+riemann-fd:: Linux file descriptor use.
+riemann-kvminstance:: Monitor KVM instances.
+riemann-ntp:: Monitor NTP
+
+The "stand-alone" tools offered in `riemann-tools` aren't included for now.
+
+== Contributing
+
+Pull requests, please.
+
+== Contributors
+
+  git shortlog -n
+
+== License
+
+The MIT License
+
+Copyright (c) 2016 Chris Riddoch
+Copyright (c) 2011-2016 Kyle Kingsbury
+

data/Rakefile

@@ -0,0 +1,125 @@
+# vim: syntax=ruby
+
+require 'yaml'
+require 'find'
+require 'asciidoctor'
+require 'erb'
+
+def installed_gem_version(name)
+  IO.popen(["gem", "list", "-l", name], 'r') do |io|
+    # this regex is using lookahead/behind to match things within \( and \), non-greedily.
+    io.readlines.grep(/^#{name}\s/).first[/(?<=\().*?(?=\))/].split(', ').first
+  end
+end
+
+def filtered_project_files()
+  Dir.chdir __dir__ do
+    Find.find(".").reject {|f| !File.file?(f) || f =~ %r{^\./(.git|tmp)} || f =~ %r{\.(so|gem)$} }.map {|f| f.sub %r{^\./}, '' }
+  end
+end
+
+adoc = Asciidoctor.load_file("README.adoc")
+summary = adoc.sections.find {|s| s.name == "Description" }.blocks[0].content.gsub(/\n/, ' ')
+description = adoc.sections.find {|s| s.name == "Description" }.blocks[1].content.gsub(/\n/, ' ')
+config = YAML.load_file(File.join(__dir__, "project.yaml"))
+project = config.fetch('name', File.split(File.expand_path(__dir__)).last)
+toplevel_module = config.fetch('toplevel_module') { project.capitalize }
+version = adoc.attributes['revnumber']
+dependencies = config.fetch('dependencies', {})
+if dependencies.nil?
+  dependencies = {}
+end
+dev_dependencies = config.fetch('dev-dependencies', {})
+if dev_dependencies.nil?
+  dev_dependencies = {}
+end
+license = config.fetch('license') { "LGPL-3.0" }
+executables = Dir.glob(File.join(__dir__, "bin", "*")).map {|f| File.basename(f) }
+#["rake", "asciidoctor", "yard", "pry", "rspec", "rspec-sequel-formatter", "#{project}-tests"]
+["rake", "asciidoctor", "yard", "pry", "rspec"].each do |dep|
+  dev_dependencies[dep] = dev_dependencies.fetch(dep) {|d| "=#{installed_gem_version(d)}" }
+end
+
+gemspec_template = <<GEMSPEC
+Gem::Specification.new do |s|
+  s.name        = "<%= project %>"
+  s.version     = "<%= version %>"
+  s.licenses    = ["<%= license %>"]
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "<%= summary %>"
+  s.description = "<%= description %>"
+  s.authors     = ["<%= adoc.author %>"]
+  s.email       = "<%= adoc.attributes['email'] %>"
+  s.date        = "<%= Date.today %>"
+  s.files       = [<%= all_files.map{|f| '"' + f + '"' }.join(",\n                   ") %>]
+  s.homepage    = "<%= adoc.attributes['homepage'] %>"
+  s.bindir      = "bin"
+  s.executables = [<%= executables.map{|f| '"' + f + '"' }.join(",\n                   ") %>]
+
+% dependencies.each_pair do |req, vers|
+  s.add_dependency "<%= req %>", "<%= vers %>"
+% end
+
+% dev_dependencies.each_pair do |req, vers|
+  s.add_development_dependency "<%= req %>", "<%= vers %>"
+% end
+end
+GEMSPEC
+
+task default: [:gen_version, :gemspec, :gemfile, :build]
+
+task :gen_version do
+  File.open(File.join("lib", project, "version.rb"), 'w') {|f|
+    f.puts "module #{toplevel_module}"
+    major, minor, tiny = *version.split(/\./).map {|p| p.to_i }
+    f.puts '  VERSION = "' + version + '"'
+    f.puts "  VERSION_MAJOR = #{major}"
+    f.puts "  VERSION_MINOR = #{minor}"
+    f.puts "  VERSION_TINY = #{tiny}"
+    f.puts "end"
+  }
+end
+
+task :gemspec => [:gen_version] do
+  files_in_git = IO.popen(["git", "ls-files"], 'r') { |io| io.readlines.map {|l| l.chomp } }
+  all_files = filtered_project_files()
+  if all_files - files_in_git
+    puts "Looks like there's some files uncommitted."
+  end
+
+  requires = all_files.grep(/\.rb$/).
+                           map {|f| File.readlines(f).grep (/^\s*require(?!_relative)/) }.
+                           flatten.
+                           map {|line| line.split(/['"]/).at(1).split('/').at(0) }.
+                           uniq
+
+  missing_deps = requires - dependencies.keys
+  if missing_deps.length > 0
+    puts "There may be some dependencies not listed for the gemspec:"
+    puts missing_deps.join(", ")
+  end
+
+  File.open(project + ".gemspec", 'w') do |f|
+    erb = ERB.new(gemspec_template, nil, "%<>")
+    f.write(erb.result(binding))
+  end
+end
+
+task :gemfile do
+  File.open("Gemfile", 'w') do |f|
+    f.puts "source 'https://rubygems.org"
+    f.puts "gemspec"
+  end
+end
+
+task :build => [:clean, :gemspec, :gemfile] do
+  system "gem build #{project}.gemspec"
+end
+
+task :install => [:build] do
+  system "gem install ./#{project}-#{version}.gem"
+end
+
+task :clean do
+  rm_f "./#{project}-#{version}.gem"
+end

data/bin/riemann-apache-status

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+# 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_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::ApacheStatus
+  include Riemann::Monitors
+  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
+    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 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
+    unless (response = get_connection).nil?
+      response.each_line do |line|
+        metrics = Hash.new
+
+        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
+
+Riemann::Monitors::ApacheStatus.run

data/bin/riemann-bench

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# Connects to a server (first arg) and populates it with a constant stream of
+# events for testing.
+
+require_relative "../lib/riemann-monitors"
+require 'pp'
+
+class Riemann::Monitors::Bench
+  include Riemann::Monitors
+
+  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 = {}
+  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
+
+Riemann::Bench.new.run

data/bin/riemann-cloudant

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+# Gathers load balancer statistics from Cloudant.com (shared cluster) and submits them to Riemann.
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Monitors::Cloudant
+  include Riemann::Monitors
+  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 = JSON.parse(get_json().body)
+    json.each do |node|
+      return 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|
+        unless ['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
+  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::Monitors::Cloudant.run

data/bin/riemann-consul

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+# Reports service and node status to riemann
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+require 'socket'
+require 'net/http'
+require 'uri'
+require 'json'
+
+class Riemann::Monitors::ConsulHealth
+  include Riemann::Monitors
+
+  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
+
+  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 = get(@consul_leader_url)
+    leader_hostname = URI.parse("http://" + leader[1..-2]).hostname
+
+    if (leader_hostname == @underlying_ip)
+      nodes = JSON.parse(get(@consul_nodes_url))
+      services = JSON.parse(get(@consul_services_url))
+      services_by_nodes = Hash.new
+
+      for node in nodes
+        node_name = node["Node"]
+        services_by_nodes[node_name] = 0
+      end
+
+
+      # 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))
+
+        totalCount = 0
+        okCount = 0
+
+        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
+
+          last_services_by_nodes = services_by_nodes[hostname].to_i
+          services_by_nodes[hostname] = last_services_by_nodes + 1
+        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
+        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
+
+Riemann::Monitors::ConsulHealth.run

data/bin/riemann-dir-files-count

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+# Gets the number of files present on a directory and submits it to riemann
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::DirFilesCount
+  include Riemann::Monitors
+
+  opt :directory, "", :default => '/var/log'
+  opt :service_prefix, "The first part of the service name, before the directory path", :default => "dir-files-count"
+  opt :warning, "Dir files number warning threshold", :type => Integer
+  opt :critical, "Dir files number critical threshold", :type => Integer
+  opt :alert_on_missing, "Send a critical metric if the directory is missing?", :default => true
+
+  def initialize
+    @dir = opts.fetch(:directory)
+    @service_prefix = opts.fetch(:service_prefix)
+    @warning = opts.fetch(:warning, nil)
+    @critical = opts.fetch(:critical, nil)
+    @alert_on_missing = opts.fetch(:alert_on_missing)
+  end
+
+  def tick
+    if Dir.exists?(@dir)
+      metric = Dir.entries(@dir).size - 2
+      report(
+        :service => "#{@service_prefix} #{@dir}",
+        :metric => metric,
+        :state => state(metric),
+        :tags => ['dir_files_count']
+      )
+    elsif @alert_on_missing
+      report(
+        :service => "#{@service_prefix} #{@dir} missing",
+        :description => "#{@service_prefix} #{@dir} does not exist",
+        :metric => metric,
+        :state => 'critical',
+        :tags => ['dir_files_count']
+      )
+    end
+  end
+
+  def state(metric)
+    if @critical && metric > @critical
+      'critical'
+    elsif @warning && metric > @warning
+      'warning'
+    else
+      'ok'
+    end
+  end
+end
+
+Riemann::Monitors::DirFilesCount.run

data/bin/riemann-dir-space

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+# Gathers the space used by a directory and submits it to riemann
+
+require_relative "../lib/riemann-monitors"
+
+class Riemann::Monitors::DirSpace
+  include Riemann::Monitors
+
+  opt :directory, "", :default => '/var/log'
+  opt :service_prefix, "The first part of the service name, before the directory path", :default => "dir-space"
+  opt :warning, "Dir space warning threshold (in bytes)", :type => Integer
+  opt :critical, "Dir space critical threshold (in bytes)", :type => Integer
+  opt :alert_on_missing, "Send a critical metric if the directory is missing?", :default => true
+
+  def initialize
+    @dir = opts.fetch(:directory)
+    @service_prefix = opts.fetch(:service_prefix)
+    @warning = opts.fetch(:warning, nil)
+    @critical = opts.fetch(:critical, nil)
+    @alert_on_missing = opts.fetch(:alert_on_missing)
+  end
+
+  def tick
+    if Dir.exists?(@dir)
+      metric = `du '#{@dir}'`.lines.to_a.last.split("\t")[0].to_i
+      report(
+        :service => "#{@service_prefix} #{@dir}",
+        :metric => metric,
+        :state => state(metric),
+        :tags => ['dir_space']
+      )
+    elsif @alert_on_missing
+      report(
+        :service => "#{@service_prefix} #{@dir} missing",
+        :description => "#{@service_prefix} #{@dir} does not exist",
+        :metric => metric,
+        :state => 'critical',
+        :tags => ['dir_space']
+      )
+    end
+  end
+
+  def state(metric)
+    if @critical && metric > @critical
+      'critical'
+    elsif @warning && metric > @warning
+      'warning'
+    else
+      'ok'
+    end
+  end
+end
+
+Riemann::Monitors::DirSpace.run