cepa-health 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cepa-health.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jon Williams
+
+MIT License
+
+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.md

@@ -0,0 +1,99 @@
+# Cepa Health Check for Rack-based Applications
+
+Cepa Health is a Rack Middleware that provides "probes". A probe is a block
+of code executed when the `/healthy` path is accessed. This path will return
+a list of the probe results, most importantly with the HTTP Status Code of
+"200 OK" for an overall successful result, or a "500 Internal Server Error" if
+any probe fails.
+
+This path is intended for use by services such as 
+[Pingdom](https://www.pingdom.com/) or [New Relic](http://newrelic.com/).
+This path is also for use with Load Balancer that use a health check, such as
+Amazon's [Elastic Load Balancer](http://aws.amazon.com/elasticloadbalancing/).
+
+See Discussion before for more details on the use of Cepa Health.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cepa-health'
+
+And then execute:
+
+    $ bundle
+
+Equally you can install without a gemfile using:
+
+	$ gem install cepa-health
+
+## Usage
+
+http://rubyonrails.org/
+If you're running a Rails application, you can generate a default initializer with
+    
+    $ rails generate cepa_health:initializer
+
+This will create a file `config/initializers/cepa_health.rb`. Refer to that file for more instructions.
+
+Alternatively, if you're running a Rack-based application (e.g. using
+[Sinatra Framework](http://www.sinatrarb.com/)) add the following to config.ru. Note this assumes you're running with [Bundler](http://bundler.io/sinatra.html) or loading the cepa-health gem yourself.
+
+    use CepaHealth::Middleware
+
+To define probes, register blocks as:
+	
+	# Create a Probe with the default level of "error"
+	CepaHealth.register "Probe Name" do
+   		record("Other result", true, "This will add another reporting row")
+   		true # Ultimate result
+	end
+
+	# Create a Probe specifically tagged as level "warn"
+	CepaHealth.register "Warning Probe", :warn do
+   		record("Other result", true, "This will add another reporting row")
+   		true # Ultimate result
+	end
+	
+The result of these Probes is summarized at the `/healthy` path when you run your Rack application. This will render a HTML table, you can similarly use `/healthy.json` or `healthy.txt` for JSON and Text results respectively. Take a look at the
+[probes directory](https://github.com/cepaorg/cepa-health/tree/master/probes) for
+some examples of probes.
+
+By default, `/healthy` will return all probes. You can cut this back using filters. For example, `healthy.txt?filters=warn` will return a Text summary of just the "warn" level Probes. `healthy.txt?filters=error,warn` resturns both "error" and "warn" probes.
+
+## Privacy
+
+You may not want your health check available to anyone - either because you want to be private about the results, or you don't want to unnecessarily reveal details of your stack. To provide an extra layer of privacy, you can set a key on your health check. Just add (or comment out in the initalizer):
+
+	CepaHealth.key = "sekret"
+
+The health check will only be available if `key=sekret` is added to the path. If it doesn't match, a blank 404 is returned.
+
+This will prevent casual access to your health check.
+
+## Discussion
+
+There are already a handful of Rack and Rails-based Health Checks. For example,
+[rack-health](https://github.com/mirakui/rack-health) or
+[rack-ping](https://github.com/jondot/rack-ping).
+
+Cepa Health addresses a handful of specific needs:
+
+- Different levels of probes. The "error" is appropriate for removing a server from a Load Balancer and raising alarms. The "warn" level may be less serious, such as a failed Delayed Job. You way still wish to raise an alert, but perhaps of different severity.
+- Simiarly, there may be other needs for uptime reporting. In this case you may only wish to measure probes that directly affect site usage.
+- Cepa Health can be stubbed out by simply adding a blank `healthy.txt` to the root directory of the given path.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Make sure you have some tests or way of validating the feature.
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+7. ... and thanks!
+
+## License
+
+MIT Licensed. See LICENSE.txt

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc 'Runs the RSpecs'
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ['--color']
+end
+
+task :default => :spec

data/cepa-health.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cepa-health/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cepa-health"
+  gem.version       = CepaHealth::VERSION
+  gem.authors       = ["Jon Williams"]
+  gem.email         = ["jon@jonathannen.com"]
+  gem.description   = %q{Health Check Middleware for Rails and Rack-based Applications}
+  gem.summary       = %q{Provides the facility for probes that are evaluated when a health URL is accessed.}
+  gem.license       = "MIT"
+  gem.homepage      = "https://github.com/cepaorg/cepa-health"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'rack', '>= 1.2.0'
+  gem.add_development_dependency 'rspec', '>= 2.0.0'
+end

data/lib/cepa-health/generator.rb

@@ -0,0 +1,35 @@
+require 'rails/generators'
+require 'securerandom'
+
+module CepaHealth
+
+  class InitializerGenerator < Rails::Generators::Base
+
+    def create_initializer_file
+      key = SecureRandom.hex(3)
+      create_file "config/initializers/cepa_health.rb", <<-CONTENT
+# Configure Cepa Health checks.
+# See: https://github.com/cepaorg/cepa-health
+
+# # Comment out the following to remove the standard probes.
+CepaHealth.load_probes 
+
+# # Comment out the below if you'd like your health check protected
+# # by a key. The new health link will now be whatever the key is. In this 
+# # example, "/healthcheck?key=#{key}"
+# CepaHealth.key = "#{key}"
+
+# # Add the following to bring a standard probe back after removing the above.
+# CepaHealth.load_probe(:rails)
+
+# # And/Or you can also add your own probes
+# CepaHealth.register "Probe Name" do
+#   record("Other result", true, "This will add another reporting row")
+#   true # Ultimate result
+# end
+CONTENT
+    end
+
+  end
+
+end

data/lib/cepa-health/middleware.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+require 'cgi'
+
+module CepaHealth
+
+  class Middleware
+    DEFAULT_PATH = /\A\/healthy(\.html|\.json|\.txt)?\z/
+
+    def initialize(app, options={})
+      @app  = app
+      @path = options.fetch(:path, DEFAULT_PATH)
+    end
+
+    def call(env)
+      path = env['PATH_INFO']
+      path_matches?(path) ? process(path, env) : @app.call(env)
+    end
+
+    protected
+
+    def determine_mime_type(path)
+      case path.split('.').last.downcase
+      when 'json' then 'application/json'
+      when 'txt' then 'text/plain'
+      else 'text/html'
+      end
+    end
+
+    def process(path, env)
+      query = env['QUERY_STRING']
+      params = Rack::Utils.parse_nested_query(query)
+      filters = params['filters']
+      filters = filters.nil? ? [] : filters.split(",").map { |v| v.strip }      
+      result = CepaHealth.execute(*filters)
+      
+      unless CepaHealth.key.nil?
+        key = params['key']
+        return [404, {}, [""]] unless key == CepaHealth.key
+      end
+
+      mime = determine_mime_type(path)
+
+      body = case mime
+      when 'text/plain' then render_text(result)
+      else render_html(result)
+      end
+
+      [result.success? ? 200: 500, { 'Content-Type' => "#{mime}; charset=utf-8" }, [body]]
+    end
+
+    def path_matches?(path)
+      case @path
+      when Proc then @path.call(path)
+      when Regexp then path =~ @path
+      else @path.to_s == path
+      end
+    end
+
+    def render_html(result)
+      rows = result.records.map do |name, status, comment|
+        stat = status ? "<td class='status ok'>OK</td>" : "<td class='status fail'>FAIL</td>"
+        "<tr>#{stat}<td class='name'>#{CGI::escapeHTML(name)}</td><td>#{CGI::escapeHTML(comment)}</td></tr>"
+      end
+      <<-HTML
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Health Check</title>
+    <style type='text/css'>
+      body {
+        font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+      }
+      div.container {
+        margin: 0 auto;
+        width: 960px;
+      }
+      
+      h1 { font-size: 20px; font-weight: bold; }
+      h2 { font-size: 22px; font-weight: bold; }
+      h2 span { font-size: 36px; }
+      
+      table {
+        border-bottom: 1px solid #999;
+        border-top: 1px solid #999;
+        margin-top: 10px;
+        width: 100%;
+      }
+
+      td { 
+        font-size: 14px; 
+        padding: 5px; 
+      }
+      td.name { background: #f7f7f7; font-weight: bold; width: 200px; }
+      td.status { font-weight: bold;  text-align: center; width: 50px; }
+      td.status.fail { background: #fdd; color: #c00; }
+      td.status.ok { background: #dfd; color: #0c0; }
+
+      .fail h2 { color: #600; }
+      .fail span { color: #c00; text-shadow: 2px 2px 0 #600; }
+      .ok h2 { color: #060; }
+      .ok span { color: #0c0; text-shadow: 2px 2px 0 #060; }
+
+    </style>
+  </head>
+  <body class='#{ result.success? ? 'ok' : 'fail'}'>
+    <div class='container'>
+      <h1>Health Check</h1>
+      <h2>#{ result.success? ? "<span>✔</span> Great, the Application is Healthy" : "<span>✘</span> Damn, something is broken"}</h2>
+      <table>#{ rows * "\n" }</table>
+    </div>
+  </body>
+</html>
+      HTML
+    end
+
+    def render_text(result)
+      body = "#Entry\t#Status\t#Comment\n"
+      body << (result.success? ? "Overall\tSuccess\n" : "Overall\tFailure\n")
+      body + result.records.map { |a,b,c| "#{a}\t#{b ? "Success" : "Failure"}\t#{c}" } * "\n"
+    end
+
+  end
+
+end

data/lib/cepa-health/railtie.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+module CepaHealth
+
+  class Railtie < Rails::Railtie
+
+    initializer "cepa_health.configure_rails_initialization" do |app|
+      app.middleware.use CepaHealth::Middleware
+    end
+
+  end
+
+end

data/lib/cepa-health/version.rb

@@ -0,0 +1,4 @@
+module CepaHealth
+  VERSION = "0.1.0"
+end
+

data/lib/cepa-health.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+module CepaHealth
+  attr_accessor :success
+
+  # Container that holds the result of the probe execution
+  class Result
+    attr_reader :records
+
+    def execute(name, block)
+      @success &&= !!(v = instance_exec(&block))
+      record(name, v, v ? "Success" : "Failed")
+    end
+
+    def initialize
+      @records = []
+      @success = true
+    end
+
+    def record(name, status, comment)
+      @records << [name, status, comment]
+    end
+
+    def success?
+      @success
+    end
+
+  end
+
+  class << self
+    attr_accessor :key
+    attr_reader :probes
+
+    def clear_probes!
+      @probes = {}
+    end
+
+    # Executes the probes.
+    # @param [ Array<String> ] filters to the given levels when the probes
+    # were registered. If no filters are specified, all probes are resulted.
+    def execute(*filters)
+      result = CepaHealth::Result.new
+      filters = filters.map { |v| v.to_s }
+      selected = filters.empty? ? probes : probes.select { |k,v| filters.include?(k) } 
+      selected.values.flatten(1).each { |v| result.execute(*v) }
+      result
+    end
+
+    # Loads an individual probe
+    def load_probe(name)
+      dir = File.expand_path(File.join(File.dirname(File.expand_path(__FILE__)), '..', 'probes'))
+      Dir[File.join(dir, name)].each { |v| require(v) }
+    end
+
+    # Scans the probes directory for Ruby files.
+    def load_probes
+      dir = File.expand_path(File.join(File.dirname(File.expand_path(__FILE__)), '..', 'probes'))
+      Dir[File.join(dir, "**/*.rb")].each { |v| require(v) }
+    end
+
+    # Registers the given block as a probe. An optional level can be supplied,
+    # which can be used as a filter.
+    def register(name, level = :error, &block)
+      list = probes[level.to_s] ||= []
+      list << [name, block]
+      self
+    end
+
+  end
+  @probes = {}
+  @key = nil
+
+end
+
+require "cepa-health/middleware"
+require "cepa-health/version"
+
+# Railtie to add the Middleware Automatically
+if defined?(Rails)
+  require 'cepa-health/generator'
+  require 'cepa-health/railtie'
+end

data/probes/delayed_job.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+if defined?(Delayed)
+
+  CepaHealth.register "Delayed Job" do
+    record "Rails Major Version", true, Rails.version.split('.').first
+    true
+  end
+
+end

data/probes/mongoid.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+

data/probes/rails.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+if defined?(Rails)
+
+  # A Trivial Rails probe.
+  CepaHealth.register "Rails" do
+    record "Rails Major Version", true, Rails.version.split('.').first
+    true
+  end
+
+end

data/probes/sqlite.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+if defined?(ActiveRecord) && defined?(SQLite3)
+
+  CepaHealth.register "SQLite" do
+    begin
+      ActiveRecord::Base.connection.exec_query("PRAGMA quick_check")
+      true
+    rescue Exception => e
+      record("SQLite Failure", false, e.inspect)
+      false
+    end
+  end
+
+end

data/spec/cepa_health_middleware_spec.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+require 'rack/lint'
+require 'rack/mock'
+require 'cepa-health'
+
+describe CepaHealth::Middleware do
+
+  before(:each) do 
+    CepaHealth.clear_probes!
+    CepaHealth.key = nil
+  end
+
+  let(:rackapp) do
+    app = ->(e) { [200, { 'Content-Type' => 'text/plain' }, ["Boom"]] }
+    Rack::Lint.new CepaHealth::Middleware.new(app)
+  end
+
+  it "should not match other URLs" do
+    code, headers, body = get("/someotherpage.html")
+    body.should == "Boom"
+  end
+
+  it "should match the healthy URL" do
+    code, headers, body = get("/healthy.html")
+    code.should == 200
+    body.should_not == "Boom"
+  end
+
+  it "should return a 200 OK for passing probes" do
+    CepaHealth.register("VeryUniqueTestIFear") { true }
+    code, headers, body = get("/healthy.html")
+    code.should == 200
+    body.should =~ /VeryUniqueTestIFear/
+  end
+
+  it "should return a 500 Error for failing probes" do
+    CepaHealth.register("VeryUniqueTestIFear") { true }
+    CepaHealth.register("TotallyUniqueFailure") { false }
+    code, headers, body = get("/healthy.html")
+    code.should == 500
+    body.should =~ /TotallyUniqueFailure/
+  end
+
+  it "should return a 404 if a key is set and not specified" do
+    CepaHealth.register("VeryUniqueTestIFear") { true }
+    CepaHealth.key = 'stone'
+    code, headers, body = get("/healthy.html")
+    code.should == 404
+    body.should == ""
+  end
+
+  it "should return successful if a key is set and specified" do
+    CepaHealth.register("VeryUniqueTestIFear") { true }
+    CepaHealth.key = 'stone'
+    code, headers, body = get("/healthy.html", 'QUERY_STRING' => 'key=stone')
+    code.should == 200
+    body.should =~ /VeryUniqueTestIFear/
+  end
+
+  it "should filter responses if they have different levels" do
+    CepaHealth.register("error1", "error") { false }
+    CepaHealth.register("error2", "error") { false }
+    CepaHealth.register("warn1", "warn") { true }
+    CepaHealth.register("warn2", "warn") { true }
+    CepaHealth.key = 'stone'
+
+    code, headers, body = get("/healthy.txt", 'QUERY_STRING' => 'key=stone')
+    code.should == 500
+    body.should =~ /error1/
+    body.should =~ /warn1/
+
+    code, headers, body = get("/healthy.txt", 'QUERY_STRING' => 'key=stone&filters=error,warn')
+    code.should == 500
+    body.should =~ /error1/
+    body.should =~ /warn1/
+
+    code, headers, body = get("/healthy.txt", 'QUERY_STRING' => 'key=stone&filters=error,other2')
+    code.should == 500
+    body.should =~ /error1/
+    body.should_not =~ /warn1/
+
+    code, headers, body = get("/healthy.txt", 'QUERY_STRING' => 'key=stone&filters=warn')
+    code.should == 200
+    body.should_not =~ /error1/
+    body.should =~ /warn1/
+  end
+
+  protected
+
+  def get(url, opts = {})
+    code, headers, lint = rackapp.call(Rack::MockRequest.env_for(url, opts))
+    body = ""; lint.each { |v| body << v.to_s }
+    [code, headers, body]
+  end
+
+end
+# describe Rack::Health do
+#   def env(url='/', *args)
+#     Rack::MockRequest.env_for(url, *args)
+#   end
+
+#   let(:base_app) do
+#     lambda do |env|
+#       [200, {'Content-Type' => 'text/plain'}, ["I'm base_app"]]
+#     end
+#   end
+#   let(:app) { Rack::Lint.new Rack::Health.new(base_app, rack_health_options) }
+#   let(:rack_health_options) { {} }
+#   let(:status) { subject[0] }
+#   let(:body) { str = ''; subject[2].each {|s| str += s }; str }
+
+#   describe 'with default options' do
+#     let(:rack_health_options) { {} }
+
+#     describe '/' do
+#       subject { app.call env('/') }
+
+#       it { status.should == 200 }
+#       it { body.should == "I'm base_app" }
+#     end
+
+#     describe '/rack_health' do
+#       subject { app.call env('/rack_health') }
+
+#       it { status.should == 200 }
+#       it { body.should == 'Rack::Health says "healthy"' }
+#     end
+#   end
+
+#   describe 'with :sick_if' do
+#     subject { app.call env('/rack_health') }
+
+#     describe '== lambda { true }' do
+#       let(:rack_health_options) { { :sick_if => lambda { true } } }
+
+#       it { status.should == 503 }
+#       it { body.should == 'Rack::Health says "sick"' }
+#     end
+
+#     describe '== lambda { false }' do
+#       let(:rack_health_options) { { :sick_if => lambda { false } } }
+
+#       it { status.should == 200 }
+#       it { body.should == 'Rack::Health says "healthy"' }
+#     end
+#   end
+
+#   describe 'with :status' do
+#     let(:status_proc) { lambda {|healthy| healthy ? 202 : 404 } }
+#     subject { app.call env('/rack_health') }
+
+#     context 'healthy' do
+#       let(:rack_health_options) { { :sick_if => lambda { false }, :status => status_proc } }
+
+#       it { status.should == 202 }
+#       it { body.should == 'Rack::Health says "healthy"' }
+#     end
+
+#     context 'sick' do
+#       let(:rack_health_options) { { :sick_if => lambda { true }, :status => status_proc } }
+
+#       it { status.should == 404 }
+#       it { body.should == 'Rack::Health says "sick"' }
+#     end
+#   end
+
+#   describe 'with :body' do
+#     let(:body_proc) { lambda {|healthy| healthy ? 'fine' : 'bad' } }
+#     subject { app.call env('/rack_health') }
+
+#     context 'healthy' do
+#       let(:rack_health_options) { { :sick_if => lambda { false }, :body => body_proc } }
+
+#       it { status.should == 200 }
+#       it { body.should == 'fine' }
+#     end
+
+#     context 'sick' do
+#       let(:rack_health_options) { { :sick_if => lambda { true }, :body => body_proc } }
+
+#       it { status.should == 503 }
+#       it { body.should == 'bad' }
+#     end
+#   end
+
+#   describe 'with :path' do
+#     subject { app.call env('/how_are_you') }
+#     let(:rack_health_options) { { :path => '/how_are_you' } }
+
+#     it { status.should == 200 }
+#     it { body.should == 'Rack::Health says "healthy"' }
+#   end
+# end

data/spec/cepa_health_spec.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+# Copyright © 2013 Jon Williams. See LICENSE.txt for details.
+
+require 'cepa-health'
+
+describe CepaHealth do
+
+  before(:each) { CepaHealth.clear_probes! }
+
+  it "should register and execute successful probes" do
+    standard_setup
+    should_be(true, 4)
+  end
+
+  it "should register a failure on any unsuccessful probe" do
+    standard_setup
+    CepaHealth.register("Fail") { false }
+    CepaHealth.register("Four") { true }
+    should_be(false, 6)
+  end
+
+  it "should allow the registration of probes in levels" do
+    CepaHealth.register("One") { false }
+    CepaHealth.register("Two", "error") { false }
+    CepaHealth.register("Three", "warn") { true }
+    CepaHealth.register("Four", "warn") { true }
+    CepaHealth.register("Five", "warn") { true }
+    should_be(false, 5)
+    should_be(false, 2, "error")
+    should_be(true, 3, "warn")
+    should_be(false, 5, %w{error warn other})
+  end
+
+  protected
+
+  def should_be(ok, record_length, filters = [])
+    r = CepaHealth.execute(*filters)
+    r.success?.should == ok
+    r.records.length.should == record_length
+    r.success?
+  end
+
+  def standard_setup
+    CepaHealth.register("One") { true }
+    CepaHealth.register("Two") { true }
+    CepaHealth.register("Three") { record("Three-B", true, "") }    
+  end
+
+end
+# describe Rack::Health do
+#   def env(url='/', *args)
+#     Rack::MockRequest.env_for(url, *args)
+#   end
+
+#   let(:base_app) do
+#     lambda do |env|
+#       [200, {'Content-Type' => 'text/plain'}, ["I'm base_app"]]
+#     end
+#   end
+#   let(:app) { Rack::Lint.new Rack::Health.new(base_app, rack_health_options) }
+#   let(:rack_health_options) { {} }
+#   let(:status) { subject[0] }
+#   let(:body) { str = ''; subject[2].each {|s| str += s }; str }
+
+#   describe 'with default options' do
+#     let(:rack_health_options) { {} }
+
+#     describe '/' do
+#       subject { app.call env('/') }
+
+#       it { status.should == 200 }
+#       it { body.should == "I'm base_app" }
+#     end
+
+#     describe '/rack_health' do
+#       subject { app.call env('/rack_health') }
+
+#       it { status.should == 200 }
+#       it { body.should == 'Rack::Health says "healthy"' }
+#     end
+#   end
+
+#   describe 'with :sick_if' do
+#     subject { app.call env('/rack_health') }
+
+#     describe '== lambda { true }' do
+#       let(:rack_health_options) { { :sick_if => lambda { true } } }
+
+#       it { status.should == 503 }
+#       it { body.should == 'Rack::Health says "sick"' }
+#     end
+
+#     describe '== lambda { false }' do
+#       let(:rack_health_options) { { :sick_if => lambda { false } } }
+
+#       it { status.should == 200 }
+#       it { body.should == 'Rack::Health says "healthy"' }
+#     end
+#   end
+
+#   describe 'with :status' do
+#     let(:status_proc) { lambda {|healthy| healthy ? 202 : 404 } }
+#     subject { app.call env('/rack_health') }
+
+#     context 'healthy' do
+#       let(:rack_health_options) { { :sick_if => lambda { false }, :status => status_proc } }
+
+#       it { status.should == 202 }
+#       it { body.should == 'Rack::Health says "healthy"' }
+#     end
+
+#     context 'sick' do
+#       let(:rack_health_options) { { :sick_if => lambda { true }, :status => status_proc } }
+
+#       it { status.should == 404 }
+#       it { body.should == 'Rack::Health says "sick"' }
+#     end
+#   end
+
+#   describe 'with :body' do
+#     let(:body_proc) { lambda {|healthy| healthy ? 'fine' : 'bad' } }
+#     subject { app.call env('/rack_health') }
+
+#     context 'healthy' do
+#       let(:rack_health_options) { { :sick_if => lambda { false }, :body => body_proc } }
+
+#       it { status.should == 200 }
+#       it { body.should == 'fine' }
+#     end
+
+#     context 'sick' do
+#       let(:rack_health_options) { { :sick_if => lambda { true }, :body => body_proc } }
+
+#       it { status.should == 503 }
+#       it { body.should == 'bad' }
+#     end
+#   end
+
+#   describe 'with :path' do
+#     subject { app.call env('/how_are_you') }
+#     let(:rack_health_options) { { :path => '/how_are_you' } }
+
+#     it { status.should == 200 }
+#     it { body.should == 'Rack::Health says "healthy"' }
+#   end
+# end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: cepa-health
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jon Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Health Check Middleware for Rails and Rack-based Applications
+email:
+- jon@jonathannen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cepa-health.gemspec
+- lib/cepa-health.rb
+- lib/cepa-health/generator.rb
+- lib/cepa-health/middleware.rb
+- lib/cepa-health/railtie.rb
+- lib/cepa-health/version.rb
+- probes/delayed_job.rb
+- probes/mongoid.rb
+- probes/rails.rb
+- probes/sqlite.rb
+- spec/cepa_health_middleware_spec.rb
+- spec/cepa_health_spec.rb
+homepage: https://github.com/cepaorg/cepa-health
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Provides the facility for probes that are evaluated when a health URL is
+  accessed.
+test_files:
+- spec/cepa_health_middleware_spec.rb
+- spec/cepa_health_spec.rb