updawg 0.3.5

data/lib/updawg/results.rb

@@ -0,0 +1,111 @@
+require 'builder'
+
+module Updawg
+  class ResultSet < Array
+    def success?
+      map { |result| result.success? }.all?
+    end
+    
+    def warning?
+      map { |result| result.warning? }.any? && !error?
+    end
+    
+    def error?
+      map { |result| result.error? }.any?
+    end
+    
+    def errors
+      select { |result| result.error? }
+    end
+    
+    def warnings 
+      select { |result| result.warning? }
+    end
+    
+    def status
+      return :error if error?
+      return :warning if warning?
+      :pass
+    end
+    
+    def to_html(builder = Builder::XmlMarkup.new)
+      builder.table('class' => status.to_s) do |b|
+        each do |result|
+          b.tr('class' => result.status.to_s) do |tr|
+            tr.td(result.name, 'class' => 'name')
+            tr.td(result.message, 'class' => 'message')
+            tr.td(result.status_text, 'class' => 'status')
+          end
+        end
+      end
+    end
+    
+    def to_text
+      map do |r|
+        "#{r.status_text}\t#{r.name} - #{r.message}\n"
+      end.join
+    end
+    
+    def nagios_report!(stream = STDOUT)
+      if error?
+        status = "CRITICAL"
+        service = errors.first
+        message = " #{service.name} #{service.message}"
+      elsif warning?
+        status ||= "WARNING" 
+        service = warnings.first
+        message = " #{service.name} #{service.message}"
+      else
+        status ||= "OK"
+        message = ""
+      end
+      
+      warning_count = warnings.size
+      error_count = errors.size
+      passed_count = size - error_count - warning_count
+             
+      service_output = ["#{status}#{message}", "OK:#{passed_count} WRN:#{warning_count} CRT:#{error_count}"]
+      stream.write "#{service_output.join("; ")}\n"
+      stream.write to_text
+      return exit(2) if error?
+      return exit(1) if warning?
+      exit(0)
+    end
+  end
+  
+  class Result
+    attr_reader :name, :status, :message
+    
+    def initialize(name, status = :pass, message = nil)
+      @name = name
+      @status = status
+      @message = message
+    end
+    
+    def success?
+      :pass == @status
+    end
+    
+    def warning?
+      :warning == @status
+    end
+    
+    def error?
+      :error == @status
+    end
+    
+    def status_text
+      return Updawg.configuration.error_text if error?
+      return Updawg.configuration.warning_text if warning?
+      Updawg.configuration.success_text
+    end
+  end
+  
+  class ResultException < Exception
+    attr_reader :result
+    
+    def initialize(result)
+      @result = result
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :development)
+
+require 'updawg'
+require 'spec'
+require 'spec/autorun'
+
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/updawg/checks/check_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Updawg::Check do
+  describe 'initialize' do
+    it 'should save the block' do
+      block = lambda { 'eep' }
+      check = Updawg::Check.new('test', &block)
+      check.instance_eval { @block }.should == block
+    end
+  end
+  
+  describe 'perform' do
+    describe 'with a successful block' do
+      before(:each) do
+        @check = Updawg::Check.new('test'){}
+        @result = @check.perform
+      end
+      
+      it 'should return a result' do
+        @result.should be_instance_of(Updawg::Result)
+      end
+      
+      it 'should be successful' do
+        @result.should be_success
+      end
+      
+      it 'should not have a message' do
+        @result.message.should == nil
+      end      
+    end
+    
+    it 'should be a warning when the block returns warning' do
+      Updawg::Check.new('test') { warning('eep') }.perform.should be_warning
+    end
+    
+    it 'should be an error when the block returns error' do
+      Updawg::Check.new('test') { error('eep') }.perform.should be_error
+    end
+
+    it 'should not eat low-level errors' do
+      expect { Updawg::Check.new('test') { xyz }.perform }.to raise_error(NameError)
+    end
+    
+    describe 'with xxx! results' do
+      it 'should not raise an exception' do
+        lambda { Updawg::Check.new('test') { pass!('everything is ok!') } }.should_not raise_error
+      end
+      
+      it 'should stop execution and be a warning after warning!' do
+        something = mock('value')
+        something.should_receive(:go).exactly(0).times
+        
+        Updawg::Check.new('test') { warning!('this executes first'); something.go() }.perform.should be_warning
+      end
+
+      it 'should stop execution and be an error after error!' do
+        something = mock('value')
+        something.should_receive(:go).exactly(0).times
+
+        Updawg::Check.new('test') { error!('this executes first'); something.go() }.perform.should be_error
+      end
+    end
+    
+    describe 'when the block raises an error' do
+      before(:each) do
+        @check = Updawg::Check.new('test'){ raise 'error: frog' }
+        lambda { @result = @check.perform }.should_not raise_error
+      end
+      
+      it 'should be an error' do
+        @result.should be_error
+      end
+      
+      it 'should have an error message' do
+        @result.message.should == 'error: frog'
+      end
+    end
+    
+    describe 'when the block execution exceeds the timeout' do
+      before(:each) do
+        @check = Updawg::Check.new('test', :timeout => 0.1){ sleep 1 }
+        @result = @check.perform
+      end
+      
+      it 'should be an error' do
+        @result.should be_error
+      end
+      
+      it 'should have a timeout message' do
+        @result.message.should match(/timeout/)
+      end
+    end
+    
+    describe 'with timeout value' do
+      before(:each) do
+        Updawg.configuration.timeout = 99
+      end
+
+      it 'should use the default if none is set' do        
+        check = Updawg::Check.new('test') {}
+        Updawg::Timeout.should_receive(:timeout).with(99)
+        check.perform
+      end
+      
+      it 'should use the check timeout if provided' do
+        check = Updawg::Check.new('test', :timeout => 5) {}
+        Updawg::Timeout.should_receive(:timeout).with(5)
+        check.perform
+      end
+    end 
+  end
+end

data/spec/updawg/checks/deviation_check_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Updawg::DeviationCheck do
+  it 'should raise ArgumentError if an invalid option is provided' do
+    lambda { 
+      subject.new('test', :im_a_little_teapot => 1){} 
+    }.should raise_error(ArgumentError)
+  end
+  
+  it 'should pass with an empty value list' do
+    check = Updawg::DeviationCheck.new('test'){ [] }
+    check.perform.should be_success
+  end
+  
+  it 'should pass with a value list containing one item' do
+    check = Updawg::DeviationCheck.new('test'){ [1] }
+    check.perform.should be_success
+  end
+  
+  it 'should pass with a value list containing two items' do
+    check = Updawg::DeviationCheck.new('test'){ [0.25, 0.25] }
+    check.perform.should be_success
+  end
+  
+  it 'should pass with a value list of all 0s' do
+    check = Updawg::DeviationCheck.new('test'){ [0, 0.0, 0, 0.0] }
+    check.perform.should be_success
+  end
+  
+  describe 'by default' do
+    before(:each) do
+      @check = Updawg::DeviationCheck.new('test'){ }
+    end
+    
+    it 'should have smoothing on' do
+      @check.smoothing.should be_true
+    end
+    
+    it 'should have a scale factor of 2' do
+      @check.scale_factor.should == 2
+    end
+  end
+  
+  describe 'with a value set' do
+    before(:each) do
+      @values = [19, 18, 16, 11, 18, 10, 16, 13, 11, 14]
+      @avg = 14.6
+      @std_dev = 3.27278338896896
+      @options = {:scale_factor => 2}
+    end
+    
+    describe 'with smoothing enabled' do
+      before(:each) do
+        @options = {:smoothing => true}
+        @smooth_values = [16, 16, 13, 14]
+        @avg = 14.75
+        @std_dev = 1.5
+      end
+      
+      it 'should error with a value above the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg + 2 * @std_dev + 0.01] }
+        result = check.perform
+        result.message.should match(/above expected maximum/)
+        result.should be_error
+      end
+    
+      it 'should error with a value below the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg - 2 * @std_dev - 0.01] }
+        result = check.perform
+        result.message.should match(/below expected minimum/)
+        result.should be_error
+      end
+    
+      it 'should pass with value in the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg] }
+        check.perform.should be_success
+      end
+    
+      it 'should pass with high edge value in the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg + 2 * @std_dev] }
+        check.perform.should be_success
+      end
+    
+      it 'should pass with low edge value in the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg - 2 * @std_dev] }
+        check.perform.should be_success
+      end
+    end
+    
+    describe 'with smoothing disabled' do
+      before(:each) do
+        @options[:smoothing] = false
+      end
+      
+      it 'should error with a value above the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg + 2 * @std_dev] }
+        result = check.perform
+        result.message.should match(/above expected maximum/)
+        result.should be_error
+      end
+    
+      it 'should error with a value below the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg - 2 * @std_dev] }
+        result = check.perform
+        result.message.should match(/below expected minimum/)
+        result.should be_error
+      end
+    
+      it 'should pass with value in the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg] }
+        check.perform.should be_success
+      end
+    
+      it 'should pass with high edge value in the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg + 2 * @std_dev - 0.01] }
+        check.perform.should be_success
+      end
+    
+      it 'should pass with low edge value in the range' do
+        check = Updawg::DeviationCheck.new('test', @options){ @values + [@avg - 2 * @std_dev + 0.01] }
+        check.perform.should be_success
+      end
+    end    
+  end
+end

data/spec/updawg/checks/threshold_check_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Updawg::ThresholdCheck do
+  it 'should raise ArgumentError if an invalid option is provided' do
+    lambda { 
+      Updawg::ThresholdCheck.new('test', :im_a_little_teapot => 1){} 
+    }.should raise_error(ArgumentError)
+  end
+  
+  it 'should accept a block for the check value' do
+    generator = mock('value')
+    generator.should_receive(:value).and_return(1)
+    
+    Updawg::ThresholdCheck.new('test') do
+      generator.value
+    end.perform    
+  end
+  
+
+  it 'should be a warning if the value is under warning threshold' do
+    Updawg::ThresholdCheck.new('test', :warning_under => 10) { 9 }.perform.should be_warning
+  end
+  
+  it 'should be a warning if the value is over warning threshold' do
+    Updawg::ThresholdCheck.new('test', :warning_over => 10) { 11 }.perform.should be_warning
+  end
+  
+  it 'should be an error if the value is over the error threshold' do
+    Updawg::ThresholdCheck.new('test', :error_over => 10) { 11 }.perform.should be_error
+  end
+  
+  it 'should be an error if the value is under the error threshold' do
+    Updawg::ThresholdCheck.new('test', :error_under => 10) { 9 }.perform.should be_error
+  end
+  
+  it 'should be successful if the value is in the sweet spot' do
+    Updawg::ThresholdCheck.new('test', 
+                               :warning_under => 9, :warning_over => 11, 
+                               :error_under => 8, :error_over => 12) do
+      10 
+    end.perform.should be_success
+  end
+end

data/spec/updawg/monitor_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Updawg::Monitor do
+  before(:each) do
+    @monitor = Updawg::Monitor.new
+  end
+  
+  describe 'by default' do
+    it 'should have an empty list of checks' do
+      @monitor.checks.should == []
+    end
+  end
+  
+  describe '#check' do
+    it 'should create a new check' do
+      @monitor.check('test'){ 'eep'}.should be_instance_of(Updawg::Check)
+    end
+    
+    it 'should set the name of the check' do
+      @monitor.check('test'){ 'eep'}.name.should == 'test'
+    end
+    
+    it 'should create a new check each call' do
+      @monitor.check('test'){}.should_not === @monitor.check('ok'){}
+    end
+    
+    it 'should add the check to the list' do
+      check = @monitor.check('test'){}
+      @monitor.checks.should include(check)
+    end
+  end
+  
+  describe '#threshold' do
+    it 'should create a threshold check' do
+      args = ['test', {}]
+      block = Proc.new{1}
+      Updawg::ThresholdCheck.should_receive(:new).with(*args, &block).and_return(check = mock('threshold'))
+      @monitor.threshold(*args, &block).should == check
+    end
+    
+    it 'should add the check to the list' do
+      check = @monitor.threshold('test')
+      @monitor.checks.should include(check)
+    end
+  end
+  
+  describe '#deviation' do
+    it 'should create a deviation check' do
+      args = ['test', {}]
+      block = Proc.new{1}
+      Updawg::DeviationCheck.should_receive(:new).with(*args, &block).and_return(check = mock('deviation'))
+      @monitor.deviation(*args, &block).should == check
+    end
+  end
+
+  describe '#perform' do
+    before(:each) do
+      @monitor.check 'One'
+      @monitor.check 'Two'
+    end
+    
+    it 'should return result set with a result for each check' do
+      results = @monitor.perform
+      results.should be_instance_of(Updawg::ResultSet)
+      results.map { |result| result.name }.should == %w(One Two)
+    end
+  end
+end