easymon 1.0.6

data/lib/easymon/checklist.rb

@@ -0,0 +1,57 @@
+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)|
+        hash[name] = Easymon::Result.new(check.check)
+        hash
+      end
+      [self.success?, self.to_s]
+    end
+    
+    def to_text
+      to_s
+    end
+    
+    def to_s
+      self.results.map{|name, result| "#{name}: #{result.to_s}"}.join("\n")
+    end
+    
+    def to_json(*args)
+      combined = []
+      self.results.each do |name, result|
+        combined << result.to_hash.merge({"name" => name})
+      end
+      combined.to_json
+    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 
+    # 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
+      raise NoSuchCheck, "No check named '#{name}'"
+    end
+  end
+end

data/lib/easymon/checks/active_record_check.rb

@@ -0,0 +1,26 @@
+module Easymon
+  class ActiveRecordCheck
+    attr_accessor :klass
+    
+    def initialize(klass)
+      self.klass = klass
+    end 
+    
+    def check
+      check_status = database_up?
+      if check_status
+        message = "Up"
+      else
+        message = "Down"
+      end
+      [check_status, message]
+    end
+    
+    private
+      def database_up?
+        1 == klass.connection.select_value("SELECT 1=1").to_i
+      rescue
+        false
+      end
+  end
+end

data/lib/easymon/checks/http_check.rb

@@ -0,0 +1,29 @@
+require "restclient"
+
+module Easymon
+  class HttpCheck
+    attr_accessor :url
+    
+    def initialize(url)
+      self.url = url
+    end 
+    
+    def check
+      check_status = http_up?(url)
+      if check_status
+        message = "Up"
+      else
+        message = "Down"
+      end
+      [check_status, message]
+    end
+    
+    private
+      def http_up?(config_url)
+        response = RestClient.head(config_url)
+        true
+      rescue Exception
+        false
+      end
+  end
+end

data/lib/easymon/checks/memcached_check.rb

@@ -0,0 +1,27 @@
+module Easymon
+  class MemcachedCheck
+    attr_accessor :cache
+    
+    def initialize(cache)
+      self.cache = cache
+    end 
+    
+    def check
+      check_status = memcached_up?
+      if check_status
+        message = "Up"
+      else
+        message = "Down"
+      end
+      [check_status, message]
+    end
+    
+    private
+      def memcached_up?
+        cache.write "health_check", 1
+        1 == cache.read("health_check")
+      rescue
+        false
+      end
+  end
+end

data/lib/easymon/checks/redis_check.rb

@@ -0,0 +1,31 @@
+require "redis"
+
+module Easymon
+  class RedisCheck
+    attr_accessor :config
+    
+    def initialize(config)
+      self.config = config
+    end 
+    
+    def check
+      check_status = redis_up?
+      if check_status
+        message = "Up"
+      else
+        message = "Down"
+      end
+      [check_status, message]
+    end
+    
+    private
+      def redis_up?
+        redis = Redis.new(@config)
+        reply = redis.ping == 'PONG'
+        redis.client.disconnect
+        reply
+      rescue
+        false
+      end
+  end
+end

data/lib/easymon/checks/semaphore_check.rb

@@ -0,0 +1,26 @@
+module Easymon
+  class SemaphoreCheck
+    attr_accessor :file_name
+    
+    def initialize(file_name)
+      self.file_name = file_name
+    end 
+    
+    def check
+      check_status = semaphore_exists?
+      if check_status
+        message = "#{file_name} is in place!"
+      else
+        message = "#{file_name} does not exist!"
+      end
+      [check_status, message]
+    end
+    
+    private
+      def semaphore_exists?
+        Rails.root.join(file_name).exist?
+      rescue
+        false
+      end
+  end
+end

data/lib/easymon/checks/split_active_record_check.rb

@@ -0,0 +1,55 @@
+module Easymon
+  class SplitActiveRecordCheck
+    attr_accessor :block
+    attr_accessor :results
+    
+    # Here we pass a block so we get a fresh instance of ActiveRecord::Base or
+    # whatever other class we might be using to make database connections
+    # 
+    # For example, given the following other class:
+    # module Easymon
+    #   class Base < ActiveRecord::Base
+    #     def establish_connection(spec = nil)
+    #       if spec
+    #         super
+    #       elsif config = Easymon.database_configuration
+    #         super config
+    #       end
+    #     end
+    #
+    #     def database_configuration
+    #       env = "#{Rails.env}_slave"
+    #       config = YAML.load_file(Rails.root.join('config/database.yml'))[env]
+    #     end
+    #   end
+    # end
+    # 
+    # We would check both it and ActiveRecord::Base like so:
+    # check = Easymon::SplitActiveRecordCheck.new {
+    #   [ActiveRecord::Base.connection, Easymon::Base.connection] 
+    # }
+    # Easymon::Repository.add("split-database", check)
+    def initialize(&block)
+      self.block = block
+    end 
+    
+    # Assumes only 2 connections
+    def check
+      connections = Array(@block.call)
+
+      results = connections.map{|connection| database_up?(connection) }
+      
+      master_status = results.first ? "Master: Up" : "Master: Down"
+      slave_status = results.last ? "Slave: Up" : "Slave: Down"
+      
+      [(results.all? && results.count > 0), "#{master_status} - #{slave_status}"]
+    end
+    
+    private
+      def database_up?(connection)
+          1 == connection.select_value("SELECT 1=1").to_i
+      rescue
+        false
+      end
+  end
+end

data/lib/easymon/checks/traffic_enabled_check.rb

@@ -0,0 +1,13 @@
+module Easymon
+  class TrafficEnabledCheck < SemaphoreCheck
+    def check
+      check_status = semaphore_exists?
+      if check_status
+        message = "ENABLED"
+      else
+        message = "DISABLED"
+      end
+      [check_status, message]
+    end
+  end
+end

data/lib/easymon/engine.rb

@@ -0,0 +1,8 @@
+module Easymon
+  class Engine < ::Rails::Engine
+    # Rails Engines weren't isolated until v3.1
+    if Gem::Version.new(Rails.version) >= Gem::Version.new('3.1')
+      isolate_namespace Easymon
+    end
+  end
+end

data/lib/easymon/repository.rb

@@ -0,0 +1,46 @@
+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
+    rescue IndexError
+      raise NoSuchCheck, "No check named '#{name}'"
+    end
+    
+    def self.all
+      Checklist.new repository
+    end
+    
+    def self.names
+      repository.keys + critical.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
+    end
+    
+    def self.remove(name)
+      repository.delete(name)
+      critical.delete(name)
+    end
+    
+    def self.repository
+      @repository ||= {}
+    end
+    
+    def self.critical
+      @critical ||= {}
+    end
+  end
+end

data/lib/easymon/result.rb

@@ -0,0 +1,32 @@
+module Easymon
+  class Result
+    attr_accessor :success
+    attr_accessor :message
+    
+    def initialize(result)
+      self.success = result[0]
+      self.message = result[1]
+    end
+    
+    def success?
+      success
+    end
+    
+    def response_status
+      success? ? :ok : :service_unavailable
+    end
+    
+    def to_s
+        message
+    end
+    
+    def to_json
+      to_hash.to_json
+    end
+    
+    def to_hash
+      {:success => success, :message => message}
+    end
+    
+  end
+end

data/lib/easymon/testing.rb

@@ -0,0 +1,15 @@
+module Easymon
+  module Testing
+    def stub_check(name)
+      Easymon.const_get("#{name.to_s.capitalize}Check").any_instance.stubs(:check)
+    end
+
+    def stub_service_success(name)
+      stub_check(name).returns([true, "Up"])
+    end
+
+    def stub_service_failure(name)
+      stub_check(name).returns([false, "Down"])
+    end
+  end
+end

data/lib/easymon/version.rb

@@ -0,0 +1,3 @@
+module Easymon
+  VERSION = "1.0.6"
+end

data/lib/tasks/easymon_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :easymon do
+#   # Task goes here
+# end

data/test/controllers/easymon/checks_controller_test.rb

@@ -0,0 +1,61 @@
+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
+      assert_response :success, "Expected success, got 503: #{response.body}"
+      assert response.body.include?("OK"), "Should include 'OK' in response body"
+    end
+
+    test "index when a critical check fails" do
+      Easymon::Repository.add("database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base), true)
+      ActiveRecord::Base.connection.stubs(:select_value).raises("boom")
+      get :index, use_route: :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), true)
+      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 :success
+      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 "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 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
+  end
+end