easymon 1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f61e81b90d2bee2ab041290388bdc30971b544d
-  data.tar.gz: 7d1cc5cb52e9210533cd4f4dce9786c710e76405
+  metadata.gz: f475318f54ddf8f1b17ce97713976eb5db32c694
+  data.tar.gz: 37c240008c8ad2ac324ea3a1c1d3cd43e51b0c47
 SHA512:
-  metadata.gz: 0104d61a2ae1fdbecc7b2178caf0eb610eb32b3a4c2d0bc5d413bb6abe75840a1e73b8b285e42a8a48291061e92783f6053d5a29f5e3280aca7ed3e9102ee7be
-  data.tar.gz: e4e71ccaac26b483bdbca036c942de0cf55103341ecbe4947bf57ca5ba3c13656366fa725aeb75fae30513aab2673650e2fc968c710cfb11d46a2b4670ec8019
+  metadata.gz: 9c0e9ed818a719eae7db9bea397a49f221a3400a26b14822809cde36e19d5b5abb623854725325041530de0897f836541dbd67f8dfb72afd1c7f0ad2ebbbdc7b
+  data.tar.gz: a9fa4f0811bdd8dd2ca2dbc1c8338aa617bc462503661fe6b4148243ea25766d8a20cfdf561e24ecc4dfd5e54111323912415599137a899a8c92e916bbc99993

data/README.md

@@ -6,7 +6,7 @@ application database, a memcached connection, or a redis instance.  These test
 results can be used by a load balancer to determine the general health and
 viability of the node your application is running on.
 
-It's packaged up as a rails engine for 3.1 and greater, and a plugin for 2.3 - 
+It's packaged up as a rails engine for 3.1 and greater, and a plugin for 2.3 -
 3.0.
 
 ## History
@@ -23,7 +23,7 @@ gem 'easymon'
 ````
 
 ## Usage
-To get started, you'll need to add an initializer for this to do anything. 
+To get started, you'll need to add an initializer for this to do anything.
 In `config/initializers/easymon.rb`:
 
 ````ruby
@@ -87,7 +87,16 @@ individually available at:
  * `/up/memcached`
  * `/up/critical` - Runs both the application-database and redis checks.
 
-## Included Checks
+## Checks
+
+A check can be any ruby code that responds_to? a #check method that returns a
+two element array. The first element is the result of executing the check and
+should be true or false. The second element is the message describing what's
+going on.  The array would look something like this: `[true, "Up"]` in the
+case of a successful check or `[false, "Timeout"]` in the case of a failed
+check.
+
+### Included Checks
 
  * ActiveRecord
  * Redis
@@ -123,11 +132,11 @@ Easymon::RedisCheck.new(
 This is the most visually complex test to instantiate, but it's only because
 we're loading the config from disk and getting the config block that matches
 the Rails.env in one line.  As long as you pass a hash that can be used by
-Redis.new.
+Redis.new, it doesn't care where the config comes from.
 
 ### Memcached
 `Easymon::MemcachedCheck` is a basic check that will write and then read a key
-from the cache.  It expects a cache instance to check, so it could be as easy 
+from the cache.  It expects a cache instance to check, so it could be as easy
 as:
 
 ````ruby
@@ -153,6 +162,7 @@ to the node.
 ````ruby
 Easymon::TrafficEnabledCheck.new("enable-traffic")
 ````
+This is a subclass of the Semaphore check mentioned above.
 
 ###Split ActiveRecord
 `Easymon::SplitActiveRecordCheck` is the most complicated check, as it's not
@@ -190,9 +200,9 @@ Easymon::Repository.add("split-database", check)
 ````
 
 ### Http
-`Easymon::HttpCheck` will check the return status of a HEAD request to a URL. 
-Great for checking service endpoint availability! The following will make a 
-request to port 9200 on localhost, which is where you might have Elasticsearch 
+`Easymon::HttpCheck` will check the return status of a HEAD request to a URL.
+Great for checking service endpoint availability! The following will make a
+request to port 9200 on localhost, which is where you might have Elasticsearch
 running:
 
 ````ruby
@@ -220,7 +230,7 @@ Here's the most direct way to get your work merged into the project:
 8. Push the branch up
 9. Send a pull request for your branch
 
-If you're going to make a major change ask first to maje sure it's in line with 
+If you're going to make a major change ask first to make sure it's in line with
 the project goals.
 
 ## To Do

data/app/controllers/easymon/checks_controller.rb

@@ -9,22 +9,23 @@ module Easymon
          format.json { render :json => e.message, :status => :not_found }
       end
     end
-    
+
     def index
       checklist = Easymon::Repository.all
       checklist.check
-      
+
       message = "No Checks Defined"
-      
+
       response_status = checklist.response_status
       message = checklist.to_s unless checklist.empty?
-      
+
       unless checklist.empty?
         # override response_status if we have a "critical" checklist
-        if checklist.include?("critical")
-          critical_checklist = checklist.fetch("critical")
-          response_status = critical_checklist.response_status
-          message = add_prefix(critical_checklist.success?, message)
+        unless Easymon::Repository.critical.empty?
+          critical_checks = checklist.items.map{|name, entry| checklist.results[name] if Easymon::Repository.critical.include?(name)}.compact
+          critical_success = critical_checks.all?(&:success?)
+          response_status = critical_success ? :ok : :service_unavailable
+          message = add_prefix(critical_success, message)
         else
           message = add_prefix(checklist.success?, message)
         end
@@ -37,14 +38,40 @@ module Easymon
     end
 
     def show
-      check = Easymon::Repository.fetch(params[:check])
       check_result = []
-      timing = Benchmark.realtime { check_result = check.check }
-      result = Easymon::Result.new(check_result, timing)
-      
+      is_critical = params[:check] == "critical"
+
+      if is_critical
+        # Build the critical checklist
+        checklist_proto = {}
+        Easymon::Repository.critical.each do |name|
+          checklist_proto[name] = Easymon::Repository.fetch(name)
+        end
+        checklist = Easymon::Checklist.new checklist_proto
+        checklist.check
+      else
+        check = Easymon::Repository.fetch(params[:check])
+        timing = Benchmark.realtime { check_result = check[:check].check }
+        result = Easymon::Result.new(check_result, timing, check[:critical])
+      end
+
+
+
       respond_to do |format|
-         format.any(:text, :html) { render :text => result, :status => result.response_status }
-         format.json { render :json => result, :status => result.response_status }
+        format.any(:text, :html) do
+          if is_critical
+            render :text => add_prefix(checklist.success?, checklist), :status => checklist.response_status
+          else
+            render :text => result, :status => result.response_status
+          end
+        end
+        format.json do
+          if is_critical
+            render :json => checklist, :status => checklist.response_status
+          else
+            render :json => result, :status => result.response_status
+          end
+        end
       end
     end
 

data/lib/easymon/checklist.rb

@@ -4,63 +4,63 @@ module Easymon
   class Checklist
     extend Forwardable
     def_delegators :@items, :size, :include?, :empty?
-    
+
     attr_accessor :items
     attr_accessor :results
-    
+
     def initialize(items={})
       self.items = items
       self.results = {}
     end
-    
+
     def check
       self.results = items.inject({}) do |hash, (name, check)|
         check_result = []
-        timing = Benchmark.realtime { check_result = check.check }
-        hash[name] = Easymon::Result.new(check_result, timing)
+        timing = Benchmark.realtime { check_result = check[:check].check }
+        hash[name] = Easymon::Result.new(check_result, timing, check[:critical])
         hash
       end
       [self.success?, self.to_s]
     end
-    
+
     def timing
       results.values.map{|r| r.timing}.inject(0, :+)
     end
-    
+
     def to_text
       to_s
     end
-    
+
     def to_s
-      results.map{|name, result| "#{name}: #{result.to_s}"}.join("\n") + 
+      results.map{|name, result| "#{name}: #{result.to_s}"}.join("\n") +
       "\n - Total Time - " + Easymon.timing_to_ms(self.timing) + "ms"
     end
-    
+
     def to_hash
-      combined = {}
+      combined = {:timing => Easymon.timing_to_ms(timing)}
       results.each do |name, result|
         combined[name] = result.to_hash
       end
       combined
     end
-    
+
     def as_json(*args)
       to_hash
     end
-    
+
     def success?
       return false if results.empty?
       results.values.all?(&:success?)
     end
-    
+
     def response_status
       success? ? :ok : :service_unavailable
     end
-    
-    # The following method could be implemented as a def_delegator by 
+
+    # The following method could be implemented as a def_delegator by
     # extending Forwardable, but since we want to catch IndexError and
     # raise Easymon::NoSuchCheck, we'll be explicit here.
-    # 
+    #
     def fetch(name)
       items.fetch(name)
     rescue IndexError

data/lib/easymon/repository.rb

@@ -1,46 +1,36 @@
 module Easymon
   class Repository
     attr_reader :repository
-    attr_reader :critical
-    
+
     def self.fetch(name)
-      if repository.include?(name)
-        return repository.fetch(name)
-      else
-        critical.fetch(name)
-      end
+      return repository.fetch(name)
     rescue IndexError
       raise NoSuchCheck, "No check named '#{name}'"
     end
-    
+
     def self.all
       Checklist.new repository
     end
-    
+
     def self.names
-      repository.keys + critical.keys
+      repository.keys
     end
-    
+
     def self.add(name, check, is_critical=false)
-      if is_critical
-        critical[name] = check
-        repository["critical"] = Checklist.new critical
-      else
-        repository[name] = check
-      end
+      entry = {:check => check, :critical => is_critical ? true : false}
+      repository[name] = entry
     end
-    
+
     def self.remove(name)
       repository.delete(name)
-      critical.delete(name)
     end
-    
+
     def self.repository
       @repository ||= {}
     end
-    
+
     def self.critical
-      @critical ||= {}
+      repository.map{ |name, entry| name if entry[:critical] }.compact
     end
   end
 end

data/lib/easymon/result.rb

@@ -3,31 +3,37 @@ module Easymon
     attr_accessor :success
     attr_accessor :message
     attr_accessor :timing
-    
-    def initialize(result, timing)
+    attr_accessor :critical
+
+    def initialize(result, timing, is_critical = false)
       self.success = result[0]
       self.message = result[1]
       self.timing = timing
+      self.critical = is_critical
     end
-    
+
     def success?
       success
     end
-    
+
+    def is_critical?
+      critical
+    end
+
     def response_status
       success? ? :ok : :service_unavailable
     end
-    
+
     def to_s
         "#{message} - #{Easymon.timing_to_ms(timing)}ms"
     end
-    
+
     def as_json(options = {})
       to_hash
     end
-    
+
     def to_hash
-      {:success => success, :message => message, :timing => Easymon.timing_to_ms(timing)}
+      {:success => success, :message => message, :timing => Easymon.timing_to_ms(timing), :critical => critical}
     end
   end
 end

data/lib/easymon/version.rb

@@ -1,3 +1,3 @@
 module Easymon
-  VERSION = "1.1"
+  VERSION = "1.2"
 end

data/test/controllers/easymon/checks_controller_test.rb

@@ -2,13 +2,13 @@ require 'test_helper'
 
 module Easymon
   class ChecksControllerTest < ActionController::TestCase
-    
+
     test "index when no checks are defined" do
       get :index, :use_route => :easymon
       assert_response :service_unavailable
       assert_equal "No Checks Defined", response.body
     end
-    
+
     test "index when all checks pass" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
       get :index, :use_route => :easymon
@@ -16,6 +16,16 @@ module Easymon
       assert response.body.include?("OK"), "Should include 'OK' in response body"
     end
 
+    test "index when a check fails" do
+      Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
+      Easymon::Repository.add("redis", Easymon::RedisCheck.new(YAML.load_file(Rails.root.join("config/redis.yml"))[Rails.env].symbolize_keys))
+      Redis.any_instance.stubs(:ping).raises("boom")
+      get :index, use_route: :easymon
+      assert_response :service_unavailable
+      assert response.body.include?("redis: Down"), "Should include failure text, got #{response.body}"
+      assert response.body.include?("DOWN"), "Should include 'OK' in response body"
+    end
+
     test "index when a critical check fails" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base), :critical)
       ActiveRecord::Base.connection.stubs(:select_value).raises("boom")
@@ -23,7 +33,7 @@ module Easymon
       assert_response :service_unavailable
       assert response.body.include?("database: Down"), "Should include failure text, got #{response.body}"
     end
-    
+
     test "index when a non-critical check fails" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base), :critical)
       Easymon::Repository.add("redis", Easymon::RedisCheck.new(YAML.load_file(Rails.root.join("config/redis.yml"))[Rails.env].symbolize_keys))
@@ -33,48 +43,47 @@ module Easymon
       assert response.body.include?("redis: Down"), "Should include failure text, got #{response.body}"
       assert response.body.include?("OK"), "Should include 'OK' in response body"
     end
-    
+
     test "index returns valid json" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
       get :index, :use_route => :easymon, :format => :json
-      
+
       json = JSON.parse(response.body)
 
       assert json.has_key?("database")
       assert_equal "Up", json["database"]["message"]
-      assert_equal 1, json.keys.count
     end
-    
+
     test "show when the check passes" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
       get :show, :use_route => :easymon, check: "database"
       assert_response :success
       assert response.body.include?("Up"), "Response should include message text, got #{response.body}"
     end
-    
+
     test "show json when the check passes" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
       get :show, :use_route => :easymon, :check => "database", :format => :json
-      
+
       json = JSON.parse(response.body)
-      
+
       assert json.has_key?("message")
       assert_equal "Up", json["message"]
     end
-    
+
     test "show when the check fails" do
       Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
       ActiveRecord::Base.connection.stubs(:select_value).raises("boom")
-      
+
       get :show, :use_route => :easymon, :check => "database"
-      
+
       assert_response :service_unavailable
       assert response.body.include?("Down"), "Response should include failure text, got #{response.body}"
     end
-    
+
     test "show if the check is not found" do
       Easymon::Repository.names.each {|name| Easymon::Repository.remove(name)}
-      
+
       get :show, :use_route => :easymon, :check => "database"
       assert_response :not_found
     end