health_monitor 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+coverage
+pkg
+doc
+rdoc
+test/tmp
+tmp

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Blythe Dunham
+
+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,119 @@
+= Health Monitor 
+Monitor individual aspects of your rails application's health
+
+Most rails applications have many additional moving parts of which the health cannot be assessed with 
+simply pinging the (hopefully page cached) homepage 
+
+For example, 
+* Is Email is sent successfully?
+* Is the SMS gateway alive and you bought sufficient credits?
+* All database connections are alive? Backgroundrb down again?
+* The cloud computing setup jacked the imagemagick? Again?
+* You are running out of disk space and there are no more file descriptors for your
+* The git SHA and version is what ?
+
+Health Monitor adds a single controller action to generate an html, js, or xml report with details of *all* 
+your custom defined health checks. An error response code (500 server error) indicates failure
+when any monitored feature fails or exceeds the custom timeout definition. Health monitor is easier to setup than
+custom server side cron tasks and adds the advantage of exercising more code since everything from your load balancer 
+to nginx to mongrels must be happily shoving rubies around to get that 200 oh boy success message.
+So ping away, grab a beer and know that hey, you might be too drunk but at least you will know your application 
+is sick before your clients do.
+
+=== Installation
+Install the plugin or gem
+  script/plugin install git://github.com/blythedunham/health_monitor
+
+  sudo gem install blythedunham-health_monitor --sources=http://gemcutter
+
+Run the generator to create HealthMonitorController
+  script/generate health_monitor
+
+=== Examples
+
+  class HealthMonitorController < ApplicationController
+    acts_as_health_monitor
+
+    # montior the database connection
+    monitor_health :database, :description => 'Check database connection'
+
+    # Monitor email sending. Fail if it exceeds 4 minutes
+    monitor_health :email,
+      :timeout => 240000 # Fail this test if it exceeds 4 minutes
+      :method => lambda{ |controller|  ActionMailer::Base.deliver_my_mail('blah') }
+
+    # Display the results of system df call with the results
+    monitor_health :check_disk, :description => 'Check Disk status' do |controller|
+      results = `df`
+      status = $? == 0 ? :success : :failure
+      { :status => status, :message => "DF: #{results}" }
+    end
+
+    protected
+    def database; ActiveRecord::Base.connection; end
+
+  end
+
+=== +monitor_health+ Options
+<tt>:description</tt> - description of the task
+<tt>:message</tt> - Defaults to SUCCESS or FAILED!
+  Additional information that is either a string or a hash with keys <tt>:success</tt> and <tt>:failure</tt>
+  Message allows more custom result information, such as the number of servers queried or IP address
+  or git version.
+
+<tt>:timeout</tt> - Fails the health check if the total time exceeds <tt>:timeout</tt> milliseconds
+<tt>:method</tt> - The name of the method or a Proc to invoke. A block can be given as well.
+Defaults to the method with the feature name
+
+=== Monitored Methods
+The proc or method defined should return its status as one of the following:
+* true or false indicating success or failure
+  monitor_health :mymonitor, :method => { |controller| ...do something ... ; true }
+
+  monitor_health :myothermonitor
+  def myothermonitor; false; end
+
+* a status symbol: of <tt>:success</tt>, <tt>:failure</tt>, <tt>:timeout</tt>, <tt>:skipped</tt>
+  monitor_health :mymonitor, :method => { |controller| ...do something ... ; :failure }
+
+* a hash of attributes including:
+** <tt>:status</tt> must be a value listed above: defaults to failure
+** <tt>:message</tt> Custom message with result data
+** <tt>:description</tt> The task description
+
+  monitor_health :mymonitor do |controller|
+    ...do something ... ;
+    { :status => :success, :message => 'My custom results for server abc', :description => 'task description' }
+  end
+
+=== Skip tests or run a single test
+To skip a test, add the skip parameter to your url with a list of comma delimited tests to skip
+  http://yayhost/health_monitor.html?skip=testblah
+  http://yayhost/health_monitor.js?skip=test1,test2
+
+To specify tests to run, use the :only parameter
+  http://yayhost/health_monitor?only=test2,test4,test5
+   
+=== Routes
+By default, the route resources are added (assume controller is named +HealthMonitorController+)
+The action defined is named +monitor_health+
+
+Base resource if show is not already defined by +health_monitor_url+
+  host/health_monitor.js?skip=mysql
+
+Member accessor +monitor_health_health_monitor+
+  host/health_monitor/monitor_health.js?only=thatone,thisone
+
+To disable and write your own routes, use +route+ option with +acts_as_health_monitor+
+  acts_as_health_monitor :route => false
+
+=== Considerations
+If you are reporting sensitive information, consider limiting this controller to specific IP addresses or 
+adding authorization logic to your controller with before_filters.
+
+=== Inspirations and Fun
+Health monitor was inspired by work at http://spongecell.com. 
+Health monitor is brought to you by the rule of threes and the letter B.
+The official mascot of health monitor is GIRAFFE! and the official drink is sparklemotion (1 part sparks, 1 part champagne)
+
+Copyright (c) 2009 Blythe Dunham. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "health_monitor"
+    gem.summary = %Q{Monitor all aspects of your applications health.}
+    gem.email = "blythe@snowgiraffe.com"
+    gem.homepage = "http://github.com/blythedunham/health_monitor"
+    gem.authors = ["Blythe Dunham"]
+    
+    gem.add_dependency('activesupport', '>= 2.1')
+    gem.add_dependency('actionpack', '>=2.1')
+    
+    #gem.add_development_dependency('timecop', '0.3.1')
+    gem.add_development_dependency('mocha', '>=0.9.8')
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "health_monitor #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/generators/health_monitor/health_monitor_generator.rb

@@ -0,0 +1,26 @@
+
+class HealthMonitorGenerator <  ControllerGenerator
+  def initialize(runtime_args, runtime_options = {})
+    runtime_args << 'health_monitor' if runtime_args.empty?
+    super runtime_args, runtime_options
+  end
+
+  protected
+
+  # Override the source path to read the parents templates for everything
+  # except the controller
+  def source_path(relative_source)
+    original_source_root = self.source_root
+    if relative_source != 'controller.rb'
+      @source_root = File.join(self.class.lookup('Controller').path, 'templates')
+    end
+    super
+  ensure
+    @source_root = original_source_root
+  end
+
+  def banner
+    "Usage: #{$0} health_monitor [controller_name] [options] \n  Default controller_name = HealthMonitorController]"
+  end
+
+end

data/generators/health_monitor/templates/_health_monitor.html.erb

@@ -0,0 +1,45 @@
+<h1>Health O Meter</h1>
+<h2>Status: <%= healthy? ?  "PASS" : "FAIL" %></h2>
+
+<table border="1" width="90%">
+  <tr>
+    <th></th>
+    <th>Name</th>
+    <th>Result</th>
+    <th>Time (s)</th>
+    <th>Description</th>
+  </tr>
+  <% monitored_features.each do |name, options| %>
+    <% result =  @results[ name ] %>
+  <tr>
+    <td style="background-color: <%=  case result.try( '[]', :status )
+      when nil, :skipped   then 'yellow'
+      when :success        then 'green'
+      when :failure        then 'red'
+      when :timeout        then 'blue'
+    end
+    -%>">
+      <%= result ? result[:status].to_s.upcase : "SKIPPED" %>
+    </td>
+    <td><%= h name.to_s.titleize %></td>
+    <td><%= h result ? result[ :message ] : "SKIPPED" %></td>
+    <td><%= h "#{result[ :time ]} s" if result %></td>
+    <td><%= h result.try( '[]', :description ) || options[ :description ] %></td>
+  </tr>
+  <% end %>
+</table>
+<br>
+<table>
+  <tr>
+    <td><b>Total Time: </b></td>
+    <td><%= h "#{@results.sum{|n, r| r[ :time ] || 0 }} seconds" %></td>
+  </tr>
+  <tr>
+    <td><b>PID: </b></td>
+    <td><%= $$ %></td>  
+  </tr>
+  <tr>
+    <td><b>Host: </b></td>
+    <td><%= request.host %></td>  
+  </tr>
+</table>

data/generators/health_monitor/templates/controller.rb

@@ -0,0 +1,31 @@
+class <%= class_name %>Controller < ApplicationController
+  acts_as_health_monitor
+
+  # Refer to the README at http://github.com/blythedunham/health_monitor
+  # for more examples
+
+  #   # montior the database connection
+  #   monitor_health :database, :description => 'Check database connection'
+  #
+  #   # Monitor email sending. Fail if it exceeds 4 minutes
+  #   monitor_health :email,
+  #   :timeout => 240000 # Fail this test if it exceeds 4 minutes
+  #   :method => lambda{ |controller|  ActionMailer::Base.deliver_my_mail('blah') }
+  #
+  #   # Display the results of system df call with the results
+  #   monitor_health :check_disk, :description => 'Check Disk status' do |controller|
+  #     results = `df`
+  #     status = $? == 0 ? :success : :failure  # base result on return code
+  #     { :status => status, :message => "DF: #{results}" }
+  #   end
+  #
+  #   protected
+  #   def database; ActiveRecord::Base.connection; end
+  #
+
+  <% for action in actions -%>
+  def <%= action %>
+  end
+
+  <% end -%>
+end

data/health_monitor.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{health_monitor}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Blythe Dunham"]
+  s.date = %q{2009-12-06}
+  s.email = %q{blythe@snowgiraffe.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "generators/health_monitor/health_monitor_generator.rb",
+     "generators/health_monitor/templates/_health_monitor.html.erb",
+     "generators/health_monitor/templates/controller.rb",
+     "health_monitor.gemspec",
+     "lib/health_monitor.rb",
+     "lib/health_monitoring.rb",
+     "templates/_health_monitor.html.erb",
+     "test/helper.rb",
+     "test/test_health_monitor.rb"
+  ]
+  s.homepage = %q{http://github.com/blythedunham/health_monitor}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Monitor all aspects of your applications health.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_health_monitor.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_runtime_dependency(%q<actionpack>, [">= 2.1"])
+      s.add_development_dependency(%q<mocha>, [">= 0.9.8"])
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_dependency(%q<actionpack>, [">= 2.1"])
+      s.add_dependency(%q<mocha>, [">= 0.9.8"])
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.1"])
+    s.add_dependency(%q<actionpack>, [">= 2.1"])
+    s.add_dependency(%q<mocha>, [">= 0.9.8"])
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/lib/health_monitor.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/health_monitoring"
+ActionController::Base.extend HealthMonitoring::ActsAsHealthMonitor

data/lib/health_monitoring.rb

@@ -0,0 +1,306 @@
+# = Health Monitor 
+# Monitor individual aspects of your rails application's health
+#
+# Most rails applications have many additional moving parts of which the health cannot be assessed with 
+# simply pinging the (hopefully page cached) homepage 
+#
+# For example, 
+# * Is Email is sent successfully?
+# * Is the SMS gateway alive and you bought sufficient credits?
+# * All database connections are alive? Backgroundrb down again?
+# * The cloud computing setup jacked the imagemagick? Again?
+# * You are running out of disk space and there are no more file descriptors for your
+# * The git SHA and version is what ?
+#
+# Health Monitor adds a single controller action to generate an html, js, or xml report with details of *all* 
+# your custom defined health checks. An error response code (500 server error) indicates failure
+# when any monitored feature fails or exceeds the custom timeout definition. Health monitor is easier to setup than
+# custom server side cron tasks and adds the advantage of exercising more code since everything from your load balancer 
+# to nginx to mongrels must be happily shoving rubies around to get that 200 oh boy success message.
+# So ping away, grab a beer and know that hey, you might be too drunk but at least you will know your application 
+# is sick before your clients do.
+# 
+# ====Examples
+#
+# class HealthMonitorController < ApplicationController
+#   acts_as_health_monitor
+#
+#   # montior the database connection
+#   monitor_health :database, :description => 'Check database connection'
+#
+#   # Monitor email sending. Fail if it exceeds 4 minutes
+#   monitor_health :email,
+#     :timeout => 240000 # Fail this test if it exceeds 4 minutes
+#     :method => lambda{ |controller|  ActionMailer::Base.deliver_my_mail('blah') }
+#
+#   # Display the results of system df call with the results
+#   monitor_health :check_disk, :description => 'Check Disk status' do |controller|
+#     results = `df`
+#     status = $? == 0 ? :success : :failure
+#     { :status => status, :message => "DF: #{results}" }
+#   end
+#
+#   protected
+#   def database; ActiveRecord::Base.connection; end
+#
+# end
+#
+# === +monitor_health+ Options
+# <tt>:description</tt> - description of the task
+# <tt>:message</tt> - Defaults to SUCCESS or FAILED!
+#   Additional information that is either a string or a hash with keys <tt>:success</tt> and <tt>:failure</tt>
+#   Message allows more custom result information, such as the number of servers queried or IP address
+#   or git version.
+#
+# <tt>:timeout</tt> - Fails the health check if the total time exceeds <tt>:timeout</tt> milliseconds
+# <tt>:method</tt> - The name of the method or a Proc to invoke. A block can be given as well.
+# Defaults to the method with the feature name
+#
+# === Monitored Methods
+# The proc or method defined should return its status as one of the following:
+# * true or false indicating success or failure
+#   monitor_health :mymonitor, :method => { |controller| ...do something ... ; true }
+#
+#   monitor_health :myothermonitor
+#   def myothermonitor; false; end
+#
+# * a status symbol: of <tt>:success</tt>, <tt>:failure</tt>, <tt>:timeout</tt>, <tt>:skipped</tt>
+#   monitor_health :mymonitor, :method => { |controller| ...do something ... ; :failure }
+#
+# * a hash of attributes including:
+# ** <tt>:status</tt> must be a value listed above: defaults to failure
+# ** <tt>:message</tt> Custom message with result data
+# ** <tt>:description</tt> The task description
+#
+#   monitor_health :mymonitor do |controller|
+#     ...do something ... ;
+#     { :status => :success, :message => 'My custom results for server abc', :description => 'task description' }
+#   end
+#
+# === Routes
+# By default, the route resources are added (assume controller is named +HealthMonitorController+)
+# The action defined is named +monitor_health+
+#
+# Base resource if show is not already defined by +health_monitor_url+
+#   host/health_monitor.js?skip=mysql
+#
+# Member accessor +monitor_health_health_monitor+
+#   host/health_monitor/monitor_health.js?only=thatone,thisone
+#
+# To disable and write your own routes, use +route+ option with +acts_as_health_monitor+
+#   acts_as_health_monitor :route => false
+#
+module HealthMonitoring
+  def self.included( base )
+    base.class_eval do
+      extend HealthMonitoring::ClassMethods
+      cattr_accessor :monitored_features
+      self.monitored_features ||= ActiveSupport::OrderedHash.new
+
+      helper_method :monitored_features, :healthy?
+      hide_action :monitored_features, :monitored_features=
+    end
+  end
+
+  # by default, this is a singleton route
+  # class HealthMonitor < ApplicationController
+  #   acts_as_health_monitor
+  # end
+  #
+  # ===Options
+  # :route => false. Will disable autogenerating named paths and routes
+  #
+  # By default, the resouces are defined as (assume controller is named +HealthMonitorController+)
+  # Base resource if show is not already defined by +health_monitor_url+
+  #   host/health_monitor.js?skip=mysql
+  #
+  # Member accessor +monitor_health_health_monitor+
+  #   host/health_monitor/monitor_health.js?only=thatone,thisone
+  #
+  module ActsAsHealthMonitor
+    def acts_as_health_monitor( options = {} )
+      include HealthMonitoring unless method_defined?( :health_monitor )
+      
+      setup_health_monitor_routes( options.delete( :route ) )
+    end
+
+    def setup_health_monitor_routes( route )
+      return if route == false
+
+      base_methods = if method_defined?( :show )
+        :none
+      else
+        alias_method :show, :monitor_health
+        :show
+      end
+
+
+      ActionController::Routing::Routes.draw do |map|
+        map.resource controller_name, :controller => controller_name, :only => base_methods, :member => { :monitor_health => :get }
+        #map.named_route controller_name, controller_name + '.:format', :conditions => {:method => :get}, :controller => controller_name, :action => 'monitor_health'
+        #map.named_route "monitor_health_#{controller_name}", "#{controller_name}/monitor_health.:format", :conditions => {:method => :get}, :controller => controller_name, :action => 'monitor_health'
+        
+        #map.resource controller_name, :controller => controller_name, :only => :none, :member => { :monitor_health => :get } do |r|
+        #  r.named_route '', '.:format', :conditions => {:method => :get}, :controller => controller_name, :action => 'monitor_health'
+        #end
+        #map.named_route route_name, route_path, :controller => controller_name, :action => 'health', :method => :get
+        #map.connect "#{controller_name}", :controller => controller_name, :action => 'health'
+      end
+    end
+  end
+
+  module ClassMethods
+    def monitor_health( *features, &block )
+      options = features.extract_options!
+      options.symbolize_keys!
+      options[:method] = block if block_given?
+      features.each {|name|  self.monitored_features[ name.to_sym ] = options }
+    end
+  end
+
+  # Show a status page showing the health of monitored features
+  # Returns a 404 if any features have a success of unsuccessful
+  #
+  # Skip features: z2live.com/health/status?skip=mongo,mysql
+  # Include features: z2live.com/health/status?feature=mongo
+  def monitor_health
+    find_features
+    @results = @features.inject({}) do |results, feature_name|
+      results[ feature_name ] = monitor_health_of( feature_name )
+      results
+    end
+    healthy? ? on_healthy : on_unhealthy
+    render_health
+  end
+
+  protected
+
+  def monitor_health_of( feature_name )
+    feature_status = { :name => feature_name }
+    result = nil
+    feature_status[ :time ] = Benchmark.ms { result = invoke_health_check( feature_name ) }
+    report_health_status!( feature_status, result )
+  end
+
+  def invoke_health_check( feature_name )
+    case method = monitored_features[ feature_name ][ :method ]
+      when Proc, Method then method.call( self)
+      when NilClass then send( feature_name )
+    else send( method )
+    end
+  rescue => e
+    return { :status => :failure, :exception => e }
+  end
+
+  def healthy?
+    (@results||{}).all?{ |name, result| result[:status] == :success }
+  end
+
+  #response code
+  def healthy_response_code()    200; end
+  def unhealthy_response_code()  500; end
+
+  #callbacks
+  def on_healthy()   end
+  def on_unhealthy() end
+
+  def health_check_template
+    File.join( File.dirname(__FILE__), "/../generators/health_monitor/templates/_health_monitor.html.erb" )
+  end
+
+  def health_response_code
+    healthy? ? healthy_response_code : unhealthy_response_code
+  end
+
+  # Render the html file
+  def render_health_html
+    render :file => health_check_template,   :status => health_response_code
+  end
+
+  # Render the json file
+  def render_health_json
+    render :text => @results.values.to_json, :status => health_response_code
+  end
+
+  # Render the xml file
+  def render_health_xml
+    render :xml  => @results.values,         :status => health_response_code
+  end
+
+  # Render the result
+  def render_health
+    return if performed?
+
+    respond_to do |format|
+      format.html { render_health_html }
+      format.js   { render_health_json }
+      format.xml  { render_health_xml  }
+    end
+  end
+
+
+
+  # Skip features by appending skip=mongo,fun,etc
+  # Include features by appending feature=mongo,urban_airship,etc to filter
+  def find_features
+    @features = if params[ :only ]
+      params[ :only ].to_s.split( "," ).collect( &:to_sym ).uniq
+
+    elsif skip = params[ :skip ] || params[ :exclude ]
+      monitored_features.keys - skip.to_s.split( "," ).collect( &:to_sym )
+
+    else
+      monitored_features.keys
+    end
+  end
+
+  def fail_health_timeout!( feature_status )
+    timeout = monitored_features[ feature_status[:name] ][:timeout]
+    if timeout && feature_status[:time].to_f >= timeout
+      feature_status.update(
+        :status => :timeout,
+        :message => "Timeout: Exceeded #{timeout} ms"
+      )
+    end
+
+    #Adjust time to seconds
+    feature_status[ :time ] = ("%.4f" % (feature_status[ :time ] / 1000)).to_f
+
+    feature_status
+  end
+
+  def set_default_health_status!( feature_status )
+    monitor_defaults = monitored_features[ feature_status[ :name ] ]
+    feature_status[ :description ] ||= monitor_defaults[ :description ]
+    health_monitor_message!( feature_status )
+  end
+
+  def health_monitor_message!( feature_status )
+    feature_status[ :message ] ||= monitored_features[ feature_status[ :name ] ][ :message ]
+    feature_status[ :message ] = feature_status[:message][ feature_status[:status] ]  if feature_status[:message].is_a?( Hash )
+    feature_status[ :message ] ||= feature_status[:status].to_s.upcase
+    feature_status[ :message ] << " Error: #{feature_status[:exception]}" if feature_status[:exception]
+    feature_status
+  end
+
+  def report_health_status!( feature_status, result )
+
+    # update the hash with the result hash
+    case result
+      when Hash then feature_status.update( result )
+      else feature_status[ :status ] = result
+    end
+
+    # symbolize variables if strings
+    # convert false to :failure
+    # otherwise the existance of any object indicates success
+    feature_status[:status] = case feature_status[:status].to_s
+      when /(failure|success|timeout|skipped)/ then feature_status[:status].to_sym
+      when 'false' then :failure
+      else !!feature_status[:status] ? :success : :failure
+    end
+  
+    fail_health_timeout!( feature_status )
+    set_default_health_status!( feature_status )
+  end
+end

data/templates/_health_monitor.html.erb

@@ -0,0 +1,29 @@
+
+<h1>Health O Meter</h1>
+<h2><%= healthy? ?  "OK" : "FAIL" %></h2>
+
+<table border="1" width="90%">
+  <tr>
+    <th></th>
+    <th>Name</th>
+    <th>Result</th>
+    <th>Time (s)</th>
+    <th>Description</th>
+  </tr>
+  <% monitored_features.each do |name, options| %>
+  <tr>
+    <td style="background-color:<%= status_color( name )%>">
+      <%= h status_text( name ) %>
+    </td>
+    <td><%= h name.to_s.titleize %></td>
+    <td><%= monitored_message( name ) %></td>
+    <td><%= monitored_timing( name ) %></td>
+    <td><%= monitored_description( name ) %></td>
+  </tr>
+  <% end %>
+</table>
+
+<br>
+<b>Total: </b><%= total_time %> <br>
+<b>PID: </b><%= $$ %><br>
+<b>host: </b><%= request.host %>

data/test/helper.rb

@@ -0,0 +1,31 @@
+# Load the environment
+require 'fileutils'
+ENV['RAILS_ENV'] = 'test'
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+# Load the testing framework
+require 'test_help'
+silence_warnings { RAILS_ENV = ENV['RAILS_ENV'] }
+
+
+gem 'shoulda'
+gem 'mocha'
+require 'shoulda'
+require 'shoulda/action_view'
+require 'shoulda/action_controller'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'health_monitor'
+
+
+test_dir = File.expand_path(File.dirname(__FILE__) + '/../tmp')
+FileUtils.mkdir_p(test_dir) unless File.exist?(test_dir)
+RAILS_LOGGER = Logger.new(test_dir + '/test.log')
+ActionController::Base.logger = nil
+
+class Test::Unit::TestCase
+end

data/test/test_health_monitor.rb

@@ -0,0 +1,124 @@
+require 'helper'
+
+#require 'shoulda/controller/macros'
+class TestHealthMonitorController < ActionController::Base
+  acts_as_health_monitor
+  
+  monitor_health :proc_test, 
+                 :method => lambda{ |c| c.params[:fail] != 'true' }, 
+                 :description => 'A proc test',
+                 :message => {:success => "Successful test.", :failure => 'Failed test'}
+                 
+  monitor_health :block_test do |controller|
+    @block_controller = controller
+    { 
+      :status => controller.send(:conditional_fail_test),
+      :message => "Params are: #{controller.params[:fail]}",
+      :description => 'A block test'
+    }
+  end
+  
+  monitor_health :conditional_fail_test
+  monitor_health :exception_test
+
+  protected
+  def conditional_fail_test( key = :fail)
+    params[key] != 'true'
+  end
+
+  def exception_test
+    raise StandardError.new("Exception test") if params[:exception] == 'true'
+    :success
+  end
+end
+
+class TestHealthMonitorControllerTest < ActionController::TestCase
+  
+  def self.ping_monitor( testname, options = {} )
+    
+    context testname do
+      expect_success = ![options[:fail], options[:exception]].include?( 'true' )
+      setup do
+        get :show, options
+        @success = expect_success#![options[:fail], options[:exception]].include?( 'true' )
+        @results = assigns(:results)
+      end
+      
+      should_respond_with( expect_success ? 200 : 500 )
+
+      should 'have the description' do
+        assert_equal 'A proc test', @results[:proc_test][:description]
+        assert_equal 'A block test', @results[:block_test][:description]
+        assert_nil @results[:conditional_fail_test][:description]
+      end
+      
+      should 'set default message based on test status' do
+        result = @success ?  'SUCCESS' : 'FAILURE'
+        assert_equal result, @results[:conditional_fail_test][:message], "Expect message #{@success} for #{@results[:conditional_fail_test]} "
+      end
+    
+      if expect_success
+        should 'set custom message on success to' do
+          assert_equal 'Successful test.', @results[:proc_test][:message]
+          assert_equal 'Params are: ',     @results[:block_test][:message]
+        end
+      else
+        should 'set custom message on failure to' do
+          assert_equal 'Failed test', @results[:proc_test][:message]
+          assert_equal 'Params are: true',     @results[:block_test][:message]
+        end
+      end 
+
+      should "have #{expect_success ? 'SUCCESS' : 'FAIL'} response" do
+        @results.each do |k,v|
+          expected_result = (k == :exception_test) || @success ? :success : :failure
+          assert_equal expected_result, v[:status], "#{k} results #{v.inspect}. Status should be #{expected_result}" 
+        end
+      end
+
+      yield if block_given?
+    end
+  end
+  
+  should_route :get, '/test_health_monitor.js', :action => :show, :format => "js", :controller => 'test_health_monitor'
+  should_route :get, '/test_health_monitor/monitor_health', :controller => 'test_health_monitor', :action => :monitor_health
+
+  ping_monitor 'health monitor web page' do
+    should_respond_with_content_type :html
+  end
+
+  ping_monitor( 'monitor unhealthy app', :fail => 'true' ) do
+    should_respond_with_content_type :html
+  end
+
+  ping_monitor 'monitor an unhealthy app with js', {:fail => 'true', :format => 'js'} do
+    should_respond_with_content_type 'text/javascript'
+  end
+
+  ping_monitor 'monitor a healthy app with js', {:format => 'js'} do
+    should_respond_with_content_type 'text/javascript'
+  end
+  
+  ping_monitor 'monitor an unhealthy app with js', {:fail => 'true', :format => 'xml'} do
+    should_respond_with_content_type :xml
+  end
+
+  ping_monitor 'monitor a healthy app with js', {:format => 'xml'} do
+    should_respond_with_content_type :xml
+  end
+  
+  context 'render a template if a test exception occurs' do
+    setup do
+      get :show, :exception => 'true'
+      @results = assigns(:results)
+    end
+    should_respond_with_content_type :html
+    should_respond_with 500
+
+    should 'fail exception test' do
+      assert_equal :failure, @results[:exception_test][:status]
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: health_monitor
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Blythe Dunham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-06 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.1"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.1"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: blythe@snowgiraffe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/health_monitor/health_monitor_generator.rb
+- generators/health_monitor/templates/_health_monitor.html.erb
+- generators/health_monitor/templates/controller.rb
+- health_monitor.gemspec
+- lib/health_monitor.rb
+- lib/health_monitoring.rb
+- templates/_health_monitor.html.erb
+- test/helper.rb
+- test/test_health_monitor.rb
+has_rdoc: true
+homepage: http://github.com/blythedunham/health_monitor
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Monitor all aspects of your applications health.
+test_files: 
+- test/helper.rb
+- test/test_health_monitor.rb