mini_check 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZThjMjY1Mzg1NWYyZDg0YjcyODE4Y2ZmMmQxNzI0NDY3YjIzYzQ5ZA==
+  data.tar.gz: !binary |-
+    YTQ5YzMwZGZhMDZkNWYzNmEyYzliYThjNzAzOWZiZTQ1MTMzNDY4NA==
+SHA512:
+  metadata.gz: !binary |-
+    MTAwNGRlMjI5ZGFmNGU0Y2VhOTUyYTM5NWVmZTQ1NzZkOGI5Mzg0NWY1ZjM2
+    M2EzNTlkZTZhZjNjNDRlYWQwMTE3ODljMmNhZDQ1OTM5MWMyMWYzNGE3ZGQ1
+    NTYzODgwNjEyMGJkNjE5NzE4YTVmNTBiMjllMjc4ODBlNjY3MGE=
+  data.tar.gz: !binary |-
+    OGQwOTJkMWRkNDI5N2JlYmRhNzU4M2E3NmFmNDE3Nzg1NDc1ZDRiMGI1ZTkw
+    YzkyNjQ0ZGZkYzM5NjkxODAxNTJlYWU0NDA2NGU0NTI1N2MzNDNjNWRhODU5
+    ZGUzZDExY2I5ZGI4MzUzMDA1OWIwYTA4NmQzNDdjYmE4Yzg4Mzc=

data/.gitignore

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

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 0.1.0, release 2014-03-09
+
+* First working version.
+

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test, :development do
+  gem 'rake'
+  gem 'rspec'
+  gem 'pry'
+  gem 'rack-test'
+end
+

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Manuel Morales, Workshare ltd., et al.
+
+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,73 @@
+# MiniCheck
+
+MiniCheck provides a simple Rack application for adding simple health checks to your app.
+The JSON output is similar to the one provided by the [Metrics](http://metrics.codahale.com/) Java library.
+It was started at [Workshare ltd.](http://www.workshare.com) as an easy way of providing monitoring to our Rack based applciations.
+
+
+## Quick Start
+
+Install the gem with the usual `gem install mini_check`.
+Build a new Rack app and register some checks
+
+```ruby
+MyHealthCheck = MiniCheck::RackApp.new(path: '/healthcheck')
+MyHealthCheck.register('health.redis_client'){ MyApp.redis_client.connected? }
+MyHealthCheck.register('health.db_connection'){ MyApp.db_connection.fetch('show tables').to_a }
+```
+
+Mount it in your `config.ru`:
+
+```ruby
+run Rack::Cascade.new([
+  MyHealthCheck,
+  MyApp,
+])
+```
+
+If you now visit `http://localhost:XXXX/healthcheck` you should get something like:
+
+```json
+{
+  "health.db_connection": {
+    "healthy": true
+  },
+  "health.redis_client": {
+    "healthy": true
+  }
+}
+```
+
+The registered lambdas should do any of the following things:
+
+* Return true if the check was successful.
+* Return false if not.
+* Raise an exception which will be understood as not healthy. Find an example of the output below:
+
+```json
+{
+  "health.db_connection": {
+    "healthy": false,
+    "error": {
+      "message": "Mysql2::Error: MySQL server has gone away",
+      "stack": [
+        "/home/manuel/sd/my_app/vendor/bundle/ruby/1.9.1/gems/sequel-4.7.0/lib/sequel/adapters/mysql2.rb:77:in `query'",
+        "/home/manuel/sd/my_app/vendor/bundle/ruby/1.9.1/gems/sequel-4.7.0/lib/sequel/adapters/mysql2.rb:77:in `block in _execute'",
+        "/home/manuel/sd/my_app/vendor/bundle/ruby/1.9.1/gems/sequel-4.7.0/lib/sequel/database/logging.rb:37:in `log_yield'",
+        "..."
+      ]
+    }
+  },
+  "health.redis_client": {
+    "healthy": true
+  }
+}
+```
+
+The http status code will be 200 if all checks are healthy and 500 otherwise.
+
+
+## License
+
+Released under the MIT License.  See the [LICENSE](LICENSE.md) file for further details.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/mini_check/check.rb

@@ -0,0 +1,44 @@
+module MiniCheck
+  class Check
+    attr_accessor :name
+    attr_accessor :healthy
+    attr_accessor :action
+    attr_accessor :exception
+
+    def initialize args = {}, &block
+      args = {name: args} if !args.is_a?(Hash)
+      args[:action] = block if block_given?
+      
+      set_attributes args
+    end
+
+    def healthy?
+      !!healthy
+    end
+
+    def run
+      begin
+        self.healthy = action.call
+        self.exception = nil
+      rescue Exception => e
+        self.healthy = false
+        self.exception = e
+      end
+    end
+
+    def to_hash
+      {}.tap do |h|
+        h[:healthy] = healthy?
+        h[:error] = {message: exception.message, stack: exception.backtrace} if exception
+      end
+    end
+
+    private
+
+    def set_attributes args = {}
+      args.each do |k,v|
+        send("#{k}=", v)
+      end
+    end
+  end
+end

data/lib/mini_check/checks_collection.rb

@@ -0,0 +1,24 @@
+module MiniCheck
+  class ChecksCollection < Array
+    def to_hash
+      resp = {}
+      each.map do |check|
+        resp[check.name] = check.to_hash
+      end
+
+      resp
+    end
+
+    def healthy?
+      !detect{|c| !c.healthy? }
+    end
+
+    def run
+      each{|c| c.run }
+    end
+    
+    def register name, &block
+      self.<< Check.new(name, &block)
+    end
+  end
+end

data/lib/mini_check/rack_app.rb

@@ -0,0 +1,52 @@
+module MiniCheck
+  class RackApp
+    attr_accessor :checks
+    attr_accessor :path
+
+    def initialize args = {}
+      set_attributes args
+    end
+
+    def checks
+      @checks ||= ChecksCollection.new
+    end
+
+    def call env
+      case "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+      when "GET #{path}"
+        checks.run
+        [status, headers, [body]]
+      else
+        [404, headers, []]
+      end
+    end
+
+    def register name, &block
+      checks.register name, &block
+    end
+
+    private
+
+    def set_attributes args = {}
+      args.each do |k,v|
+        send("#{k}=", v)
+      end
+    end
+
+    def headers
+      {'Content-Type' => 'application/json'}
+    end
+
+    def body
+      checks.to_hash.to_json
+    end
+
+    def generally_healthy?
+      checks.healthy?
+    end
+
+    def status
+      generally_healthy? ? 200 : 500
+    end
+  end
+end

data/lib/mini_check/version.rb

@@ -0,0 +1,3 @@
+module MiniCheck
+  VERSION = '0.1.0'
+end

data/lib/mini_check.rb

@@ -0,0 +1,8 @@
+require 'json'
+
+module MiniCheck
+  autoload :VERSION, 'mini_check/version'
+  autoload :Check, 'mini_check/check'
+  autoload :ChecksCollection, 'mini_check/checks_collection'
+  autoload :RackApp, 'mini_check/rack_app'
+end

data/mini_check.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mini_check/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mini_check'
+  spec.version       = MiniCheck::VERSION
+  spec.authors       = ['Manuel Morales']
+  spec.email         = ['manuelmorales@gmail.com']
+  spec.description   = %q{MiniCheck provides a simple Rack application for adding simple health checks to your app.}
+  spec.summary       = %q{MiniCheck provides a simple Rack application for adding simple health checks to your app.}
+  spec.homepage      = 'https://github.com/workshare/mini-check'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_runtime_dependency 'json'
+end

data/spec/helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rspec'
+require 'pry'
+
+RSpec.configure do |config|
+   config.color_enabled = true
+   config.tty = true
+   config.formatter = :documentation # :documentation, :progress, :html, :textmate
+end
+
+$LOAD_PATH.unshift File.expand_path('lib')
+require 'mini_check'
+
+$LOAD_PATH.unshift File.expand_path('spec/support')

data/spec/mini_check/check_spec.rb

@@ -0,0 +1,137 @@
+require_relative '../helper'
+
+shared_examples_for 'check' do
+  it{ should respond_to(:to_hash) }
+  it{ should respond_to(:name) }
+  it{ should respond_to(:healthy?) }
+  it{ should respond_to(:run) }
+end
+
+describe MiniCheck::Check do
+  subject{ MiniCheck::Check.new name: name, action: action }
+  let(:name){ 'my_check' }
+  let(:action){ proc{ true } }
+  let(:exception){ Exception.new('My message') }
+
+  it_behaves_like 'check'
+
+  describe 'initialize' do
+    it 'allows passing attributes as a hash' do
+      check = MiniCheck::Check.new name: name, action: action 
+      expect(check.name).to eq(name)
+      expect(check.action).to eq(action)
+    end
+
+    it 'allows building by name and proc' do
+      check = MiniCheck::Check.new(name, &action)
+
+      expect(check.name).to eq(name)
+      expect(check.action).to eq(action)
+    end
+  end
+
+  describe 'run' do
+    it 'calls the action' do
+      action.should receive(:call)
+      subject.run
+    end
+
+    context 'when the action returns an object (success)' do
+      before :each do
+        allow(action).to receive(:call).and_return(Object.new)
+      end
+
+      it 'sets the healthy? to true' do
+        subject.healthy = nil
+        subject.run
+        expect(subject.healthy?).to eq(true)
+      end
+
+      it 'blanks the exception' do
+        subject.exception = Exception.new
+        subject.run
+        expect(subject.exception).to be_nil
+      end
+    end
+
+    context 'when the action returns false' do
+      before :each do
+        allow(action).to receive(:call).and_return(false)
+      end
+
+      it 'sets the healthy? to false' do
+        subject.healthy = true
+        subject.run
+        expect(subject.healthy?).to eq(false)
+      end
+
+      it 'blanks the exception' do
+        subject.exception = Exception.new
+        subject.run
+        expect(subject.exception).to be_nil
+      end
+    end
+
+    context 'when the action raises an exception' do
+      before :each do
+        allow(action).to receive(:call).and_raise(exception)
+      end
+
+      it 'sets the healthy? to false' do
+        subject.healthy = true
+        subject.run
+        expect(subject.healthy?).to eq(false)
+      end
+
+      it 'sets the exception to the exception' do
+        subject.exception = nil
+        subject.run
+        expect(subject.exception).to be(exception)
+      end
+    end
+  end
+
+  describe 'to_hash' do
+    context 'when the run was successful' do
+      before :each do
+        allow(action).to receive(:call).and_return(Object.new)
+      end
+
+      it 'returns the basic healthy hash' do
+        subject.run
+        expect(subject.to_hash).to eq(healthy: true)
+      end
+    end
+
+    context 'when the action returns false' do
+      before :each do
+        allow(action).to receive(:call).and_return(false)
+      end
+
+      it 'returns the basic healthy hash' do
+        subject.run
+        expect(subject.to_hash).to eq(healthy: false)
+      end
+    end
+
+    context 'when the action raises an exception' do
+      before :each do
+        exception.stub(backtrace: ['a'])
+        allow(action).to receive(:call).and_raise(exception)
+      end
+
+      it 'returns the hash with error' do
+        subject.run
+        expect(subject.to_hash).to eq(
+          {
+            :healthy => false,
+            :error => {
+              :message => exception.message,
+              :stack => exception.backtrace,
+            }
+          }
+        )
+      end
+    end
+  end
+end

data/spec/mini_check/checks_collection_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../helper'
+
+shared_examples_for 'checks collection' do
+  it{ should respond_to(:to_hash) }
+  it{ should respond_to(:healthy?) }
+  it{ should respond_to(:<<) }
+  it{ should respond_to(:run) }
+end
+
+describe MiniCheck::ChecksCollection do
+  it_behaves_like 'checks collection'
+
+  let(:check_hash){ {healthy: true} }
+  let(:check){ build_check(name: 'my_check') }
+
+  def build_check args = {}
+    stubs = {healthy?: true, to_hash: check_hash, run: true}
+    @name_counter ||= 0
+    stubs[:name] = "name_#{@name_counter += 1}"
+    stubs.merge! args
+    
+    double(stubs[:name], stubs)
+  end
+
+  describe 'to_hash' do
+    it 'uses the name as key' do
+      subject << check_1 = build_check
+      subject << check_2 = build_check
+
+      expected_hash = {
+        check_1.name => check_hash,
+        check_2.name => check_hash,
+      }
+
+      expect(subject.to_hash).to eq(expected_hash)
+    end
+  end
+
+  describe 'healthy?' do
+    it 'is true when all are true' do
+      subject << build_check(healthy?: true)
+      subject << build_check(healthy?: true)
+      subject << build_check(healthy?: true)
+
+      expect(subject.healthy?).to eq(true)
+    end
+
+    it 'is true when one is false' do
+      subject << build_check(healthy?: true)
+      subject << build_check(healthy?: false)
+      subject << build_check(healthy?: true)
+
+      expect(subject.healthy?).to eq(false)
+    end
+  end
+
+  describe 'run' do
+    it 'runs each of the checks' do
+      subject << check
+
+      expect(check).to receive(:run)
+      subject.run
+    end
+  end
+
+  describe 'register' do
+    it 'adds a new check to the collection' do
+      name = 'asd'
+      block = proc{}
+
+      expect(MiniCheck::Check).to receive(:new).with(name, &block).and_return(check)
+      subject.register(name, &block)
+      expect(subject.last).to be(check)
+    end
+  end
+end
+

data/spec/mini_check/rack_app_spec.rb

@@ -0,0 +1,102 @@
+require_relative '../helper'
+require 'rack/test'
+
+describe MiniCheck::RackApp do
+  include Rack::Test::Methods
+
+  subject{ MiniCheck::RackApp.new checks: checks, path: '/health'}
+  let(:app){ subject }
+  let(:checks_hash){ {'my_check' => {'health' => true}} }
+  let(:checks){ double(:healthy? => true, :to_hash => checks_hash, :<< => true, :run => true) }
+
+  def status
+    last_response.status
+  end
+
+  def headers
+    last_response.headers
+  end
+
+  def body
+    last_response.body
+  end
+
+  def body_json
+    JSON.parse(body)
+  end
+
+  describe :call do
+    it 'returns status, headers, body' do
+      get '/'
+      expect(status).to be_a(Fixnum)
+      expect(headers).to be_a(Hash)
+      expect(body).to be_a(String)
+    end
+
+    context 'unknown path' do
+      it 'returns status 404' do
+        get '/blahblah'
+        expect(status).to eq(404)
+      end
+    end
+
+    context 'unknown verb' do
+      it 'returns status 404' do
+        post '/health'
+        expect(status).to eq(404)
+      end
+    end
+
+    context 'GET /health' do
+      def do_request
+        get '/health'
+      end
+
+      it 'returns status 200' do
+        do_request
+        expect(status).to eq(200)
+      end
+
+      it 'returns content type json' do
+        do_request
+        expect(headers['Content-Type']).to eq('application/json')
+      end
+
+      it 'returns JSON body' do
+        do_request
+        expect(JSON.parse(body)).to eq(checks_hash)
+      end
+
+      it 'calls run on the checks' do
+        expect(checks).to receive(:run).and_return(true)
+        do_request
+      end
+
+      it 'returns each check' do
+        expect(checks).to receive(:healthy?).and_return(true)
+        do_request
+      end
+
+      it 'has status 500 when one check is failing' do
+        expect(checks).to receive(:healthy?).and_return(true)
+        do_request
+      end
+    end
+  end
+
+  describe 'register' do
+    it 'forwards to checks' do
+      name = 'asd'
+      block = proc{}
+      expect(checks).to receive(:register).with(name, &block)
+      subject.register(name, &block)
+    end
+  end
+
+  ## MOCKS ##
+  
+  describe 'checks' do
+    subject{ checks }
+    it_behaves_like 'checks collection'
+  end
+end

data/spec/mini_check_spec.rb

@@ -0,0 +1,5 @@
+require_relative 'helper'
+require 'mini_check'
+
+describe MiniCheck do
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: mini_check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Manuel Morales
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MiniCheck provides a simple Rack application for adding simple health
+  checks to your app.
+email:
+- manuelmorales@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/mini_check.rb
+- lib/mini_check/check.rb
+- lib/mini_check/checks_collection.rb
+- lib/mini_check/rack_app.rb
+- lib/mini_check/version.rb
+- mini_check.gemspec
+- spec/helper.rb
+- spec/mini_check/check_spec.rb
+- spec/mini_check/checks_collection_spec.rb
+- spec/mini_check/rack_app_spec.rb
+- spec/mini_check_spec.rb
+homepage: https://github.com/workshare/mini-check
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: MiniCheck provides a simple Rack application for adding simple health checks
+  to your app.
+test_files:
+- spec/helper.rb
+- spec/mini_check/check_spec.rb
+- spec/mini_check/checks_collection_spec.rb
+- spec/mini_check/rack_app_spec.rb
+- spec/mini_check_spec.rb