riemann-tools-dgvz 0.2.2.1

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.markdown

@@ -0,0 +1,18 @@
+Riemann Tools
+=============
+
+Tiny programs to submit events to Riemann.
+
+Riemann-health, for example, submits events about the current CPU, load,
+memory, and disk use. Bench submits randomly distributed metrics for load
+testing. I've got a whole bunch of these internally for monitoring Redis, Riak,
+queues, etc. Most have internal configuration dependencies, so it'll be a while
+before I can extract them for re-use.
+
+Get started
+==========
+
+``` bash
+gem install riemann-tools
+riemann-health --host my.riemann.server
+```

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 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
+
+
+  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::Tools::ApacheStatus.run

data/bin/riemann-aws-billing

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+require 'fog'
+
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+$0 = __FILE__
+
+class Riemann::Tools::AWSBilling
+  include Riemann::Tools
+
+  opt :fog_credentials_file, "Fog credentials file", :type => String
+  opt :fog_credential, "Fog credentials to use", :type => String
+
+  opt :access_key, "AWS access key", :type => String
+  opt :secret_key, "Secret access key", :type => String
+  opt :services, "AWS services: AmazonEC2  AmazonS3  AWSDataTransfer", :type => :strings, :multi => true, :default => ["AmazonEC2", "AmazonS3", "AWSDataTransfer"]
+
+  opt :time_start, "Start time in seconds of the metrics period (2hrs ago default)", :type => Integer, :default => 7200
+  opt :time_end, "End time in seconds of the metrics period ", :type => Integer, :default => 60
+
+
+  def initialize
+    if options[:fog_credentials_file]
+      Fog.credentials_path = opts[:fog_credentials_file]
+      Fog.credential = opts[:fog_credential].to_sym
+      @cloudwatch = Fog::AWS::CloudWatch.new
+    else
+      @cloudwatch = Fog::AWS::CloudWatch.new(:aws_secret_access_key => opts[:secret_key], :aws_access_key_id => opts[:access_key])
+      @start_time = (Time.now.utc - opts[:time_start]).iso8601
+      @end_time = (Time.now.utc - opts[:time_end]).iso8601
+    end
+  end
+
+  def tick
+    opts[:services].each do |service|
+      data = @cloudwatch.get_metric_statistics({
+                                                 'Statistics' => ["Maximum"],
+                                                 'StartTime' => @start_time,
+                                                 'EndTime' => @end_time,
+                                                 'Period' => 3600,
+                                                 'Unit' => "None",
+                                                 'MetricName' => "EstimatedCharges",
+                                                 'Namespace' => "AWS/Billing",
+                                                 'Dimensions' => [
+                                                                  {
+                                                                    'Name' => "ServiceName",
+                                                                    'Value' => service
+                                                                  },
+                                                                  {
+                                                                    'Name' => "Currency",
+                                                                    'Value' => "USD"
+                                                                  }
+                                                                 ]
+                                               }).body['GetMetricStatisticsResult']['Datapoints']
+
+
+      data.each do |metrics|
+        name = "AWScloudwatch.Billing." + service
+        value = metrics["Maximum"]
+        timestamp = metrics["Timestamp"].to_i
+
+        event = {
+          host: nil,
+          service: name,
+          time: timestamp,
+          description: "AWS Estimate Charges for #{service}",
+          tags: ["aws_billing"],
+          state: "ok",
+          metric: value
+        }
+
+        report event
+      end
+    end
+  end
+end
+
+Riemann::Tools::AWSBilling.run

data/bin/riemann-aws-status

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'fog'
+require 'date'
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+$0 = __FILE__  # Let's not expose our AWS keys in the process list
+
+class Riemann::Tools::AWS
+  include Riemann::Tools
+  
+  opt :access_key, "AWS access key", :type => String
+  opt :secret_key, "Secret access key", :type => String
+  opt :region, "AWS region", :type => String, :default => 'eu-west-1'
+
+  opt :retirement_critical, "Number of days before retirement. Defaults to 2", :default => 2
+  opt :event_warning, "Number of days before event. Defaults to nil (i.e. when the event appears)", :default => nil
+
+  def initialize
+    @compute = Fog::Compute.new(:aws_access_key_id => opts[:access_key],
+                                :aws_secret_access_key => opts[:secret_key],
+                                :region => opts[:region],
+                                :provider => 'AWS')
+  end
+
+  def tick 
+    instance_status = @compute.describe_instance_status.body["instanceStatusSet"]
+    status = instance_status.inject({}) do |acc,i|
+      acc[i.delete("instanceId")] = i
+      acc 
+    end
+
+    hosts = @compute.servers.select { |s| s.state == "running" }.
+      inject([status, {}]) do |(status, acc), host| 
+        acc[host.private_dns_name] = status.delete(host.id); [status, acc] 
+      end[1]
+
+    hosts.each do |host, status|
+      status['eventsSet'].each do |event|
+        before, after = ['notBefore', 'notAfter'].map { |k| Date.parse event[k].to_s if event[k] }
+
+        ev = {:host => host,
+              :service => "aws_instance_status",
+              :description => "#{event['code']}\n\nstart #{event['notBefore']}\nend #{event['notAfter']}\n\n#{event['description']}",
+              :state => "ok",
+              :ttl => 300}
+
+        ev2 = if (event['code'] == 'instance-retirement') and
+          Date.today >= before-opts[:retirement_critical]
+          {:state => "critical"}
+        elsif opts[:event_warning] and Date.today >= before-opts[:event_warning]
+          {:state => "warning"}
+        else
+          {:state => "warning"}
+        end
+
+        report ev.merge(ev2)
+      end
+    end
+  end
+end
+  
+Riemann::Tools::AWS.run

data/bin/riemann-bench

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+# Connects to a server (first arg) and populates it with a constant stream of
+# events for testing.
+
+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
+
+  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::Tools::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 = 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::Tools::Cloudant.run

data/bin/riemann-diskstats

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+#
+require 'rubygems'
+require 'riemann/tools'
+
+class Riemann::Tools::Diskstats
+  include Riemann::Tools
+
+  opt :devices, "Devices to monitor", :type => :strings, :default => nil
+  opt :ignore_devices, "Devices to ignore", :type => :strings, :default =>nil
+
+  def initialize
+    @old_state = nil
+  end
+
+  def state
+    f = File.read('/proc/diskstats')
+    state = f.split("\n").reject { |d| d =~ /(ram|loop)/ }.inject({}) do |s, line|
+      if line =~ /^(?:\s+\d+){2}\s+([\w\d\-]+) (.*)$/
+        dev = $1
+
+        ['reads reqs',
+        'reads merged',
+        'reads sector',
+        'reads time',
+        'writes reqs',
+        'writes merged',
+        'writes sector',
+        'writes time',
+        'io reqs',
+        'io time',
+        'io weighted'
+        ].map do |service|
+          "#{dev} #{service}"
+        end.zip(
+          $2.split(/\s+/).map { |str| str.to_i }
+        ).each do |service, value|
+          s[service] = value
+        end
+      end
+
+      s
+    end
+
+    # Filter interfaces
+    if is = opts[:devices]
+      state = state.select do |service, value|
+        is.include? service.split(' ').first
+      end
+    end
+
+    if ign = opts[:ignore_devices]
+      state = state.reject do |service, value|
+        ign.include? service.split(' ').first
+      end
+    end
+
+    state
+  end
+
+  def tick
+    state = self.state
+
+    if @old_state
+      state.each do |service, metric|
+        delta = metric - @old_state[service]
+
+        report(
+          :service => "diskstats " + service,
+          :metric => (delta.to_f / opts[:interval]),
+          :state => "ok"
+        )
+
+        if service =~ /io time$/
+          report(:service => "diskstats " + service.gsub(/time/, 'util'),
+                 :metric => (delta.to_f / (opts[:interval]*1000)),
+                 :state => "ok")
+        end
+      end
+    end
+
+    @old_state = state
+  end
+end
+
+Riemann::Tools::Diskstats.run

data/bin/riemann-elasticsearch

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/riemann/tools', __FILE__)
+
+class Riemann::Tools::Elasticsearch
+  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 :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