riemann-tools 0.1.3 → 0.1.4

data/bin/riemann-elasticsearch

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Elasticsearch
+  include Riemann::Tools
+
+  require 'faraday'
+  require 'json'
+
+  opt :read_timeout, 'Faraday read timeout', type: :int, default: 2
+  opt :open_timeout, 'Faraday open timeout', type: :int, default: 1
+  opt :es_host, 'Elasticsearch host', default: "localhost"
+  opt :es_port, 'Elasticsearch port', type: :int, default: 9200
+
+
+  # Handles HTTP connections and GET requests safely
+  def safe_get(uri)
+      # Handle connection timeouts
+      response = nil
+      begin
+        connection = Faraday.new(uri)
+        response = connection.get do |req|
+          req.options[:timeout] = options[:read_timeout]
+          req.options[:open_timeout] = options[:open_timeout]
+        end
+      rescue => e
+        report(:host => uri.host,
+          :service => "elasticsearch health",
+          :state => "critical",
+          :description => "HTTP connection error: #{e.class} - #{e.message}"
+        )
+      end
+      response
+  end
+
+  def health_url
+    "http://#{options[:es_host]}:#{options[:es_port]}/_cluster/health"
+  end
+
+  def tick
+    uri = URI(health_url)
+    response = safe_get(uri)
+
+    return if response.nil?
+
+    if response.status != 200
+        report(:host => uri.host,
+          :service => "elasticsearch health",
+          :state => "critical",
+          :description => "HTTP connection error: #{response.status} - #{response.body}"
+        )
+    else
+      # Assuming that a 200 will give json
+      json = JSON.parse(response.body)
+      cluster_name = json.delete("cluster_name")
+      cluster_status = json.delete("status")
+      state = case cluster_status
+      when "green"
+        "ok"
+      when "yellow"
+        "warning"
+      when "red"
+        "critical"
+      end
+
+      report(:host => uri.host,
+             :service => "elasticsearch health",
+             :state => state,
+             :description => "Elasticsearch cluster: #{cluster_name} - #{cluster_status}")
+
+      json.each_pair do |k,v|
+        report(:host => uri.host,
+               :service => "elasticsearch #{k}",
+               :metric => v,
+               :description => "Elasticsearch cluster #{k}"
+        )
+
+      end
+    end
+  end
+
+
+
+end
+Riemann::Tools::Elasticsearch.run

data/bin/riemann-elb-metrics

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+$0 = __FILE__
+
+class Riemann::Tools::ELBMetrics
+  include Riemann::Tools
+
+  require 'fog'
+  require 'time'
+
+  opt :fog_credentials_file, "Fog credentials file", :type => String
+  opt :fog_credential, "Fog credentials to use", :type => String
+  opt :aws_access, "AWS Access Key", :type => String
+  opt :aws_secret, "AWS Secret Key", :type => String
+  opt :aws_region, "AWS Region", :type => String, :default => "eu-west-1"
+  opt :aws_azs, "List of AZs to aggregate against", :type => :strings, :default => [ "all_az" ]
+  opt :elbs, "List of ELBs to pull metrics from", :type => :strings, :required => true
+
+  def standard_metrics
+    # ELB metric types, from:
+    # http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html#elb-metricscollected
+    metric_options = {
+      "Latency" => {
+        "Unit" => "Seconds",
+        "Statistics" => ["Maximum", "Minimum", "Average" ]
+      },
+      "RequestCount" => {
+        "Unit" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HealthyHostCount" => {
+        "Units" => "Count",
+        "Statistics" => [ "Minimum", "Maximum", "Average" ]
+      },
+      "UnHealthyHostCount" => {
+        "Units" => "Count",
+        "Statistics" => [ "Minimum", "Maximum", "Average" ]
+      },
+      "HTTPCode_ELB_4XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_ELB_5XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_2XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_3XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_4XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      },
+      "HTTPCode_Backend_5XX" => {
+        "Units" => "Count",
+        "Statistics" => [ "Sum" ]
+      }
+    }
+
+    metric_options
+  end
+
+  def base_metrics
+    # get last 60 seconds
+    start_time = (Time.now.utc - 60).iso8601
+    end_time = Time.now.utc.iso8601
+
+    # The base query that all metrics would get
+    metric_base = {
+      "Namespace" => "AWS/ELB",
+      "StartTime" => start_time,
+      "EndTime" => end_time,
+      "Period" => 60,
+    }
+
+    metric_base
+  end
+
+
+  def tick
+    if options[:fog_credentials_file]
+      Fog.credentials_path = options[:fog_credentials_file]
+      Fog.credential = options[:fog_credential].to_sym
+      connection = Fog::AWS::CloudWatch.new
+    else
+      connection = Fog::AWS::CloudWatch.new({
+        :aws_access_key_id => options[:aws_access],
+        :aws_secret_access_key => options[:aws_secret],
+        :region => options[:aws_region]
+      })
+    end
+
+    options[:elbs].each do |lb|
+
+      metric_options = standard_metrics
+      metric_base_options = base_metrics
+
+      options[:aws_azs].each do |az|
+        metric_options.keys.sort.each do |metric_type|
+          merged_options = metric_base_options.merge(metric_options[metric_type])
+          merged_options["MetricName"] = metric_type
+          if az == "all_az"
+            merged_options["Dimensions"] = [ { "Name" => "LoadBalancerName", "Value" => lb } ]
+          else
+            merged_options["Dimensions"] = [
+              { "Name" => "LoadBalancerName", "Value" => lb },
+              { "Name" => "AvailabilityZone" , "Value" => az}
+            ]
+          end
+
+          result = connection.get_metric_statistics(merged_options)
+
+          # "If no response codes in the category 2XX-5XX range are sent to clients within 
+          # the given time period, values for these metrics will not be recorded in CloudWatch"
+          #next if result.body["GetMetricStatisticsResult"]["Datapoints"].empty? && metric_type =~ /[2345]XX/
+          #
+          # BUG:
+          # Metrics are reported every 60 seconds, but sometimes there isn't one there yet.
+          # We can skip that, or do something else?
+          next if result.body["GetMetricStatisticsResult"]["Datapoints"].empty?
+
+          # We should only ever have a single data point
+          result.body["GetMetricStatisticsResult"]["Datapoints"][0].keys.sort.each do |stat_type|
+            next if stat_type == "Unit"
+            next if stat_type == "Timestamp"
+
+            unit = result.body["GetMetricStatisticsResult"]["Datapoints"][0]["Unit"]
+            metric = result.body["GetMetricStatisticsResult"]["Datapoints"][0][stat_type]
+            event = Hash.new
+            event = {
+              host: lb,
+              service: "elb.#{az}.#{metric_type}.#{stat_type}",
+              ttl: 60,
+              description: "#{lb} #{metric_type} #{stat_type} (#{unit})",
+              tags: [ "production", "elb_metrics" ],
+              metric: metric
+            }
+
+            report(event)
+          end
+        end
+      end
+    end
+  end
+end
+
+Riemann::Tools::ELBMetrics.run

data/bin/riemann-fd

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# Reports current file descriptor use to riemann.
+# By default reports the total system fd usage, can also report usage of individual processes
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Health
+  include Riemann::Tools
+
+  opt :fd_sys_warning, "open file descriptor threshold for system", :default => 800
+  opt :fd_sys_critical, "open file descriptor critical threshold for system", :default => 900
+  opt :fd_proc_warning, "open file descriptor threshold for process", :default => 800
+  opt :fd_proc_critical, "open file descriptor critical threshold for process", :default => 900
+  opt :processes, "list of processes to measure fd usage in addition to system total", :type => :ints
+
+  def initialize
+    @limits = {
+      :fd => {:critical => opts[:fd_sys_critical], :warning => opts[:fd_sys_warning]},
+      :process => {:critical => opts[:fd_proc_critical], :warning => opts[:fd_proc_warning]},
+    }
+    ostype = `uname -s`.chomp.downcase
+    puts "WARNING: OS '#{ostype}' not explicitly supported. Falling back to Linux" unless ostype == "linux"
+    @fd = method :linux_fd
+  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_fd
+    sys_used = Integer(`lsof | wc -l`)
+    if sys_used > @limits[:fd][:critical]
+      alert "fd sys", :critical, sys_used, "system is using #{sys_used} fds"
+    elsif sys_used > @limits[:fd][:warning]
+      alert "fd sys", :warning, sys_used, "system is using #{sys_used} fds"
+    else
+      alert "fd sys", :ok, sys_used, "system is using #{sys_used} fds"
+    end
+
+    unless opts[:processes].nil?
+      opts[:processes].each do |process|
+        used = Integer(`lsof -p #{process} | wc -l`)
+        name, pid = `ps axo comm,pid | grep -w #{process}`.split
+        if used > @limits[:process][:critical]
+          alert "fd #{name} #{process}", :critical, used, "process #{name} #{process} is using #{used} fds"
+        elsif used > @limits[:process][:warning]
+          alert "fd #{name} #{process}", :warning, used, "process #{name} #{process} is using #{used} fds"
+        else
+          alert "fd #{name} #{process}", :ok, used, "process #{name} #{process} is using #{used} fds"
+        end
+      end
+    end
+  end
+
+  def tick
+    @fd.call
+  end
+end
+
+Riemann::Tools::Health.run

data/bin/riemann-net

@@ -30,6 +30,7 @@ class Riemann::Tools::Net
         'rx multicast',
         'tx bytes',
         'tx packets',
+        'tx errs',
         'tx drops',
         'tx fifo',
         'tx colls',

data/bin/riemann-nginx-status

@@ -49,7 +49,25 @@ class Riemann::Tools::NginxStatus
   end
 
   def tick
-    response = Net::HTTP.get(@uri)
+    response = nil
+    begin
+      response = Net::HTTP.get(@uri)
+    rescue => 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 { |v| v.to_i }
 
     @keys.zip(values).each do |key, value|

data/bin/riemann-rabbitmq

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+#
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Rabbitmq
+  include Riemann::Tools
+
+  require 'faraday'
+  require 'json'
+  require 'uri'
+
+
+  opt :read_timeout, 'Faraday read timeout', type: :int, default: 2
+  opt :open_timeout, 'Faraday open timeout', type: :int, default: 1
+
+  opt :monitor_user, 'RabbitMQ monitoring user', type: :string
+  opt :monitor_pass, 'RabbitMQ monitoring user password', type: :string
+  opt :monitor_port, 'RabbitMQ monitoring port', default: 15672
+  opt :monitor_host, 'RabbitMQ monitoring host', default: "localhost"
+
+  def monitor_url
+    "http://#{options[:monitor_user]}:#{options[:monitor_pass]}@#{options[:monitor_host]}:#{options[:monitor_port]}/api/overview"
+  end
+
+  def event_host
+    if options[:event_host]
+      return options[:event_host]
+    else
+      return options[:monitor_host]
+    end
+  end
+
+  def safe_get(uri, event_host)
+      # Handle connection timeouts
+      response = nil
+      begin
+        connection = Faraday.new(uri)
+        response = connection.get do |req|
+          req.options[:timeout] = options[:read_timeout]
+          req.options[:open_timeout] = options[:open_timeout]
+        end
+      rescue => e
+        report(:host => event_host,
+          :service => "rabbitmq monitoring",
+          :state => "critical",
+          :description => "HTTP connection error: #{e.class} - #{e.message}"
+        )
+      end
+      response
+  end
+
+  def tick
+    uri = URI(monitor_url)
+    response = safe_get(uri, event_host)
+
+    return if response.nil?
+
+    json = JSON.parse(response.body)
+
+    if response.status != 200
+        report(:host => event_host,
+          :service => "rabbitmq",
+          :state => "critical",
+          :description => "HTTP connection error: #{response.status} - #{response.body}"
+        )
+    else
+      report(:host => event_host,
+        :service => "rabbitmq monitoring",
+        :state => "ok",
+        :description => "HTTP connection ok"
+      )
+
+      %w( message_stats queue_totals object_totals ).each do |stat|
+        # NOTE / BUG ?
+        # Brand new servers can have blank message stats. Is this ok?
+        # I can't decide.
+        next if json[stat].empty?
+        json[stat].each_pair do |k,v|
+          service = "rabbitmq.#{stat}.#{k}"
+          if k =~ /details$/
+            metric = v['rate']
+          else
+            metric = v
+          end
+
+          # TODO: Set state via thresholds which can be configured
+
+          report(:host => event_host,
+                 :service => service,
+                 :metric => metric,
+                 :description => "RabbitMQ monitor"
+                )
+        end
+      end
+    end
+  end
+end
+Riemann::Tools::Rabbitmq.run

data/bin/riemann-redis

@@ -34,25 +34,32 @@ class Riemann::Tools::Redis
   end
 
   def tick
-    @redis.info(@section).each do |property, value|
-      data = {
-        :host    => opts[:redis_host],
-        :service => "redis #{property}",
-        :metric  => value.to_f,
-        :state   => 'ok',
-        :tags    => ['redis']
-      }
-
-      if STRING_VALUES.include?(property) || property.match(/^db\d+/)
-        if %w{ rdb_last_bgsave_status aof_last_bgrewrite_status }.include?(property)
-          data[:state] = value
-        else
-          data[:description] = value
+    begin
+      @redis.info(@section).each do |property, value|
+        data = {
+          :host    => opts[:redis_host],
+          :service => "redis #{property}",
+          :metric  => value.to_f,
+          :state   => value.to_s,
+          :tags    => ['redis']
+        }
+
+        if STRING_VALUES.include?(property) || property.match(/^db\d+/)
+          if %w{ rdb_last_bgsave_status aof_last_bgrewrite_status }.include?(property)
+            data[:state] = value
+          else
+            data[:description] = value
+          end
         end
-      end
 
-      report(data)
+        report(data)
+      end
+    rescue ::Redis::CommandError => e
+      if e.message == "ERR operation not permitted"
+        @redis.auth(opts[:redis_password]) unless opts[:redis_password] == ''
+      end
     end
+
   end
 
 end

data/bin/riemann-resmon

@@ -65,6 +65,11 @@ class Riemann::Tools::Resmon
         )
         next
       else
+        report(:host => event_host,
+          :service => "resmon",
+          :state => "ok",
+          :description => "Resmon connection ok"
+        )
         doc = Nokogiri::XML(response.body)
       end
 
@@ -78,8 +83,10 @@ class Riemann::Tools::Resmon
           }
 
           case metric.attributes['type'].value
-            when /[iIlLn]/
-              hash[:metric] = metric.text
+            when /[iIlL]/
+              hash[:metric] = metric.text.to_i
+            when 'n'
+              hash[:metric] = metric.text.to_f
             when 's'
               hash[:description] = metric.text
             when '0'

data/bin/riemann-riak

@@ -5,12 +5,13 @@
 require File.expand_path('../../lib/riemann/tools', __FILE__)
 
 require 'net/http'
+require 'net/https'
 require 'yajl/json_gem'
 
 class Riemann::Tools::Riak
   include Riemann::Tools
 
-  opt :riak_host, "Riak host", :default => Socket.gethostname
+  opt :riak_host, "Riak host for stats <IP> or SSL http(s)://<IP>", :default => Socket.gethostname
   opt :data_dir, "Riak data directory", :default => '/var/lib/riak'
   opt :stats_port, "Riak HTTP port for stats", :default => 8098
   opt :stats_path, "Riak HTTP stats path", :default => '/stats'
@@ -39,8 +40,17 @@ class Riemann::Tools::Riak
 
     if
       begin
-        Net::HTTP.start(opts[:riak_host], opts[:stats_port]) do |http|
-          http.get opts[:stats_path]
+        uri = URI.parse(opts[:riak_host])
+      if uri.host == nil
+      uri.host = opts[:riak_host]
+      end
+        http = Net::HTTP.new(uri.host, opts[:stats_port])
+        http.use_ssl = uri.scheme == 'https'
+          if http.use_ssl?
+              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        http.start do |http|
+        http.get opts[:stats_path]
       end
       rescue => e
         @httpstatus = false
@@ -50,7 +60,7 @@ class Riemann::Tools::Riak
     # dynamically input the cookie
     # this is done only once - hopefully it doesn't get overridden.
     ENV['ERL_AFLAGS'] = "-setcookie #{opts[:cookie]}"
-    
+
   end
 
   def check_ring
@@ -129,9 +139,18 @@ class Riemann::Tools::Riak
   def check_stats
     if @httpstatus
       begin
-        res = Net::HTTP.start(opts[:riak_host], opts[:stats_port]) do |http|
-          http.get opts[:stats_path]
+        uri = URI.parse(opts[:riak_host])
+        if uri.host == nil
+          uri.host = opts[:riak_host]
         end
+        http = Net::HTTP.new(uri.host, opts[:stats_port])
+        http.use_ssl = uri.scheme == 'https'
+        if http.use_ssl?
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        res = http.start do |http|
+          http.get opts[:stats_path]
+      end
       rescue => e
         report(
           :host => opts[:riak_host],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riemann-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-28 00:00:00.000000000 Z
+date: 2013-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riemann-client
@@ -148,15 +148,19 @@ executables:
 - riemann-redis-slowlog
 - riemann-bench
 - riemann-freeswitch
+- riemann-elb-metrics
 - riemann-riak
 - riemann-health
 - riemann-memcached
 - riemann-haproxy
+- riemann-elasticsearch
 - riemann-riak-keys
 - riemann-diskstats
+- riemann-fd
 - riemann-riak-ring
 - riemann-cloudant
 - riemann-nginx-status
+- riemann-rabbitmq
 - riemann-kvminstance
 - riemann-net
 - riemann-redis
@@ -168,6 +172,9 @@ files:
 - bin/riemann-bench
 - bin/riemann-cloudant
 - bin/riemann-diskstats
+- bin/riemann-elasticsearch
+- bin/riemann-elb-metrics
+- bin/riemann-fd
 - bin/riemann-freeswitch
 - bin/riemann-haproxy
 - bin/riemann-health
@@ -176,6 +183,7 @@ files:
 - bin/riemann-munin
 - bin/riemann-net
 - bin/riemann-nginx-status
+- bin/riemann-rabbitmq
 - bin/riemann-redis
 - bin/riemann-redis-slowlog
 - bin/riemann-resmon