updawg 0.3.5

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+Gemfile.lock
+
+## rubymine
+.idea

data/CHANGELOG

@@ -0,0 +1,8 @@
+0.3.3:
+  * ADD text reporting
+  * ADD check timeouts
+  * ADD std deviation checks
+0.3.2:
+  * FIX handling of StandardError in checks
+0.3.1:
+  * ADD nagios reporting

data/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+gem "builder", '~>2.1'
+gem 'aggregate'
+
+group :development do
+  gem "rspec", "~> 1.3"
+  gem "hpricot", '~>0.8'
+end
+
+group :test do
+  gem 'SystemTimer', :platforms => :ruby
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Viximo, Inc.
+
+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.rdoc

@@ -0,0 +1,99 @@
+= updawg
+
+A simple way to see what's up, dawg (and what's not.)
+
+Define a list of checks and create a controller that renders the results.  Ping the controller with
+the monitoring tool of your choice, perhaps setting a 503 response when one of the checks fails.
+
+Some options can be set:
+  UpDawg.configure do |config|
+    config.success_text = 'OK'
+  end
+
+Checks are defined with a simple DSL:
+
+  monitor = Updawg.monitor do
+    check 'MySQL' do
+      # Will raise an exception if the connection is unavailable resulting in a failed check
+      ActiveRecord::Base.connection.execute('SELECT 1 FROM DUAL')
+    end
+  
+    check 'Some threshold' do
+      result ||=   error('Threshold exceeded y') if threshold_value > y
+      result ||= warning('Threshold exceeded x') if threshold_value > x
+  	result 
+    end
+
+    # alternatively, use warning!/error!/pass! to break out of the check immediately
+    check 'Something else' do
+      warning!('Something kind of bad happened') if threshold_value > x
+      error!  ('Something really bad happened')  if threshold_value > y
+
+  	pass!('Everything is just fine')
+    end
+  
+    # Specify a threshold check for captured purchases in the last 24 hours
+    threshold 'Captured Purchases (24 hours)', :warn_under => 10, :error_under => 1 do
+      Purchase.captured_at_after(24.hours.ago)
+    end
+  
+    # Specify a "sweet spot threshold check" to alert when a business metric goes out of normal range
+    threshold 'Transactions (24 hours)',
+              :warn_under => 100, :error_under => 1,
+              :warn_over => 1000, :error_over => 2000 do
+      Transaction.created_at_after(24.hours.ago)
+    end
+    
+    # Specify a std deviation check to alert when a value is outside of 2 std deviations from the mean
+    # The block should yield an array of values, the last of which is considered the sample.
+    # Supports options:
+    #   scale_factor - multiple of the std_dev to user (default: 2)
+    #   smoothing - whether to ignore outliers in the dataset (default: true)
+    deviation 'Hourly Transaction Value' do
+      Transaction.group('hour').order('hour ASC') # will report if the last hour of data is our of range
+    end
+  end
+
+  results = monitor.perform
+
+  results.success? => true if no checks error
+  results.warning? => true if no checks error and at least one has a warning
+  results.error?   => true if at least one check fails
+
+Render with:
+  results.to_html
+    
+  <table class="updawg monitor">
+    <tr class="check error">
+      <td class="name">MySQL</td>
+      <td class="message">ActiveRecord::StatementInvalid: Mysql::Error: You have an error in your SQL syntax</td>
+      <td class="status">ERROR</td>
+    </tr>
+    <tr class="check pass">
+      <td class="name">Some threshold</td>
+      <td class="message"></td>
+      <td class="status">PASS</td>
+    </tr>
+  </table>
+
+=== Nagios Integration
+  Use Updawg to easily script nagios checks in Ruby.  Create your checks as usual and call #nagios_report!
+  on the result.  Updawg will print a status line formatted for nagios and exit with an appropriate status code.
+  
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Create a feature branch and make your feature addition or bug fix there.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request.
+
+== Authors
+
+Matt Griffin http://github.com/betamatt (matt@griffinonline.org)
+
+== Copyright
+
+Copyright (c) 2010 Viximo, Inc. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+require 'bundler'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "updawg"
+    gem.summary = %Q{A simple way to see what's up, dawg (and what's not.)}
+    gem.email = "matt@griffinonline.org"
+    gem.homepage = "http://github.com/Viximo/updawg"
+    gem.authors = ["Matt Griffin"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    
+    gem.files = `git ls-files`.split("\n")
+    gem.test_files = `git ls-files -- spec/*`.split("\n")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "updawg #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.5

data/lib/updawg.rb

@@ -0,0 +1,36 @@
+require 'updawg/monitor'
+require 'updawg/checks'
+require 'updawg/results'
+
+module Updawg
+    
+  class Configuration
+    attr_accessor :error_text, :warning_text, :success_text, :timeout
+    
+    def initialize
+      self.error_text = 'ERROR'
+      self.warning_text = 'WARNING'
+      self.success_text = 'PASS'
+      self.timeout = 30
+    end
+  end
+  
+  class << self
+    attr_accessor :configuration
+  end
+  self.configuration = Configuration.new
+  
+  class << self
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+      configuration
+    end
+    
+    def monitor(&block)
+      monitor = Updawg::Monitor.new
+      monitor.instance_eval(&block)
+      monitor
+    end
+  end
+end

data/lib/updawg/checks.rb

@@ -0,0 +1,3 @@
+require 'updawg/checks/check'
+require 'updawg/checks/deviation_check'
+require 'updawg/checks/threshold_check'

data/lib/updawg/checks/check.rb

@@ -0,0 +1,67 @@
+module Updawg  
+  begin
+    require 'system_timer'
+    Timeout = SystemTimer
+  rescue LoadError
+    module Timeout
+      class << self
+        public :timeout
+      end
+    end
+  end
+  
+  class Check
+    attr_reader :name
+    
+    def initialize(name, options = {}, &block)
+      @name = name
+      @block = block
+      @timeout = options.delete(:timeout) || Updawg.configuration.timeout
+    end
+    
+    def perform
+      result = execute_check
+      return result if result.kind_of?(Result)
+      pass
+    rescue RuntimeError => e
+      error e.message
+    end
+    
+    def pass(message = nil)
+      Updawg::Result.new(name, :pass, message)
+    end
+    
+    def warning(message = nil)
+      Updawg::Result.new(name, :warning, message)
+    end
+    
+    def error(message = nil)
+      Updawg::Result.new(name, :error, message)
+    end
+
+    def pass!(message = nil)
+      raise ResultException.new(Updawg::Result.new(name, :pass, message))
+    end
+    
+    def warning!(message = nil)
+      raise ResultException.new(Updawg::Result.new(name, :warning, message))
+    end
+    
+    def error!(message = nil)
+      raise ResultException.new(Updawg::Result.new(name, :error, message))
+    end
+
+    
+    private
+    
+      def execute_check
+        begin
+          Updawg::Timeout.timeout(@timeout) { instance_eval(&@block) } if @block
+        rescue ::Timeout::Error
+          raise 'timeout'
+        rescue ResultException => exception
+          exception.result
+        end
+      end
+  end
+end

data/lib/updawg/checks/deviation_check.rb

@@ -0,0 +1,64 @@
+require 'aggregate'
+
+module Updawg
+  class DeviationCheck < Check
+    def initialize(name, options = {}, &block)
+      super(name, options, &block)
+      
+      unknown_keys = options.keys - [:deviates_high, :deviates_low, :scale_factor, :smoothing].flatten
+      raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+            
+      @options = options
+      @scale_factor = options.fetch(:scale_factor, 2)
+      @smoothing = options.fetch(:smoothing, true)
+    end
+  
+    def scale_factor
+      @scale_factor
+    end
+    
+    def smoothing
+      @smoothing
+    end
+    
+    private
+  
+      def execute_check
+        values = @block.call
+        sample = values.pop
+        
+        return pass('Not enough data.') if sample.nil? || values.size < 2
+        
+        aggregate = Aggregate.new
+        values.each {|v| aggregate << v}
+        std_dev = aggregate.std_dev
+                  
+        mean = aggregate.mean 
+        min = mean - std_dev
+        max = mean + std_dev
+      
+        if smoothing
+          without_outliers = values.select{|v| v >= min && v <= max}
+          smoothed_aggregate = Aggregate.new
+          without_outliers.each {|v| smoothed_aggregate << v}
+          mean = smoothed_aggregate.mean
+          std_dev = smoothed_aggregate.std_dev
+        end
+        
+        min = mean - scale_factor * std_dev
+        max = mean + scale_factor * std_dev
+                  
+        return low(sample, min) if sample < min
+        return high(sample, max) if sample > max
+        return pass("#{sample} within expected range (#{min..max})")
+      end
+    
+      def low(value, min)
+        send(@options.fetch(:deviates_low, :error), "#{value} is below expected minimum (#{min})")
+      end
+    
+      def high(value, max)
+        send(@options.fetch(:deviates_high, :error), "#{value} is above expected maximum (#{max})")
+      end
+  end
+end

data/lib/updawg/checks/threshold_check.rb

@@ -0,0 +1,36 @@
+module Updawg
+  class ThresholdCheck < Check
+    def initialize(name, options = {}, &block)
+      super(name, options, &block)
+      
+      unknown_keys = options.keys - [:error_under, :error_over, :warning_under, :warning_over].flatten
+      raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+    
+      @options = options
+    end
+  
+    private
+  
+      def execute_check
+        value = @block.call
+      
+        return under(:error, value, @options[:error_under]) if @options[:error_under] && 
+          value < @options[:error_under]
+        return over(:error, value, @options[:error_over]) if @options[:error_over] && 
+          value > @options[:error_over]
+        return under(:warning, value, @options[:warning_under]) if @options[:warning_under] && 
+          value < @options[:warning_under]
+        return over(:warning, value, @options[:warning_over]) if @options[:warning_over] && 
+          value > @options[:warning_over]
+        pass("#{value} OK")
+      end
+    
+      def under(type, value, limit)
+        send(type, "Threshold lower bound exceeded: Got #{value}, expected > #{limit}")
+      end
+    
+      def over(type, value, limit)
+        send(type, "Threshold upper bound exceeded: Got #{value}, expected < #{limit}")
+      end
+  end
+end

data/lib/updawg/monitor.rb

@@ -0,0 +1,33 @@
+module Updawg
+  class Monitor
+    attr_accessor :checks
+    
+    def initialize
+      self.checks = []
+    end
+    
+    def check(name, options = {}, &block)
+      check = Updawg::Check.new(name, options, &block).tap do |check|
+        self.checks << check
+      end
+    end
+    
+    def threshold(name, options = {}, &block)
+      check = Updawg::ThresholdCheck.new(name, options, &block).tap do |check|
+        self.checks << check
+      end
+    end
+    
+    def deviation(name, options = {}, &block)
+      Updawg::DeviationCheck.new(name, options, &block).tap do |check|
+        self.checks << check
+      end
+    end
+    
+    def perform
+      results = ResultSet.new
+      checks.each{|c| results << c.perform}
+      results
+    end    
+  end
+end