is_it_working 1.0.10

data/lib/is_it_working/filter.rb

@@ -0,0 +1,55 @@
+module IsItWorking
+  # Wrapper around a status check.
+  class Filter
+    class AsyncRunner < Thread
+      attr_accessor :filter_status
+    end
+    
+    class SyncRunner
+      attr_accessor :filter_status
+      
+      def initialize
+        yield
+      end
+      
+      def join
+      end
+    end
+    
+    attr_reader :name, :async
+    
+    # Create a new filter to run a status check. The name is used for display purposes.
+    def initialize(name, check, async = true)
+      @name = name
+      @check = check
+      @async = async
+    end
+    
+    # Run a status the status check. This method keeps track of the time it took to run
+    # the check and will trap any unexpected exceptions and report them as failures.
+    def run
+      status = Status.new(name)
+      runner = (async ? AsyncRunner : SyncRunner).new do
+        t = Time.now
+        begin
+          @check.call(status)
+        rescue Exception => e
+          status.fail("#{name} error: #{e.inspect}")
+        end
+        status.time = Time.now - t
+      end
+      runner.filter_status = status
+      runner
+    end
+    
+    class << self
+      # Run a list of filters and return their status objects
+      def run_filters (filters)
+        runners = filters.collect{|f| f.run}
+        statuses = runners.collect{|runner| runner.filter_status}
+        runners.each{|runner| runner.join}
+        statuses
+      end
+    end
+  end
+end

data/lib/is_it_working/handler.rb

@@ -0,0 +1,152 @@
+module IsItWorking
+  # Rack handler that will run a set of status checks on the application and report the
+  # results. The results are formatted in plain text. If any of the checks fails, the
+  # response code will be 500 Server Error.
+  #
+  # The checks to perform are defined in the initialization block. Each check needs a name
+  # and can either be a predefined check, block, or an object that responds to the +call+
+  # method. When a check is called, its +call+ method will be called with a Status object.
+  #
+  # === Example
+  #
+  #   IsItWorkingHandler.new do |h|
+  #     # Predefined check to determine if a directory is accessible
+  #     h.check :directory, "/var/myapp", :read, :write
+  #
+  #     # Custom check using a block
+  #     h.check :solr do
+  #       SolrServer.available? ? ok("solr is up") : fail("solr is down")
+  #     end
+  #   end
+  class Handler
+    PATH_INFO = "PATH_INFO".freeze
+    
+    # Create a new handler. This method can take a block which will yield itself so it can
+    # be configured.
+    #
+    # The handler can be set up in one of two ways. If no arguments are supplied, it will
+    # return a regular Rack handler that can be used with a rackup +run+ method or in a
+    # Rails 3+ routes.rb file. Otherwise, an application stack can be supplied in the first
+    # argument and a routing path in the second (defaults to <tt>/is_it_working</tt>) so
+    # it can be used with the rackup +use+ method or in Rails.middleware.
+    def initialize(app=nil, route_path="/is_it_working", &block)
+      @app = app
+      @route_path = route_path
+      @hostname = `hostname`.chomp
+      @filters = []
+      @mutex = Mutex.new
+      yield self if block_given?
+    end
+
+    def call(env)
+      if @app.nil? || env[PATH_INFO] == @route_path
+        statuses = []
+        t = Time.now
+        statuses = Filter.run_filters(@filters)
+        render(statuses, Time.now - t)
+      else
+        @app.call(env)
+      end
+    end
+
+    # Set the hostname reported the the application is running on. By default this is set
+    # the system hostname. You should override it if the value reported as the hostname by
+    # the system is not useful or if exposing it publicly would create a security risk.
+    def hostname=(val)
+      @hostname = val
+    end
+    
+    # Add a status check to the handler.
+    #
+    # If a block is given, it will be used as the status check and will be yielded to
+    # with a Status object.
+    #
+    # If the name matches one of the pre-defined status check classes, a new instance will
+    # be created using the rest of the arguments as the arguments to the initializer. The
+    # pre-defined classes are:
+    #
+    # * <tt>:action_mailer</tt> - Check if the send mail configuration used by ActionMailer is available
+    # * <tt>:active_record</tt> - Check if the database connection for an ActiveRecord class is up
+    # * <tt>:dalli</tt> - DalliCheck checks if all the servers in a MemCache cluster are available using dalli
+    # * <tt>:directory</tt> - DirectoryCheck checks for the accessibilty of a file system directory
+    # * <tt>:memcache</tt> - MemcacheCheck checks if all the servers in a MemCache cluster are available using memcache-client
+    # * <tt>:ping</tt> - Check if a host is reachable and accepting connections on a port
+    # * <tt>:url</tt> - Check if a getting a URL returns a success response
+    def check (name, *options_or_check, &block)
+      raise ArgumentError("Too many arguments to #{self.class.name}#check") if options_or_check.size > 2
+      check = nil
+      options = {:async => true}
+      
+      unless options_or_check.empty?
+        if options_or_check[0].is_a?(Hash)
+          options = options.merge(options_or_check[0])
+        else
+          check = options_or_check[0]
+        end
+        if options_or_check[1].is_a?(Hash)
+          options = options.merge(options_or_check[1])
+        end
+      end
+      
+      unless check
+        if block
+          check = block
+        else
+          check = lookup_check(name, options)
+        end
+      end
+      
+      @filters << Filter.new(name, check, options[:async])
+    end
+    
+    # Helper method to synchronize a block of code so it can be thread safe.
+    # This method uses a Mutex and is not re-entrant. The synchronization will
+    # be only on calls to this handler.
+    def synchronize
+      @mutex.synchronize do
+        yield
+      end
+    end
+
+    protected
+      # Lookup a status check filter from the name and arguments
+      def lookup_check(name, options) #:nodoc:
+        check_class_name = "#{name.to_s.gsub(/(^|_)([a-z])/){|m| m.sub('_', '').upcase}}Check"
+        check = nil
+        if IsItWorking.const_defined?(check_class_name)
+          check_class = IsItWorking.const_get(check_class_name)
+          check = check_class.new(options)
+        else
+          raise ArgumentError.new("Check not defined #{check_class_name}")
+        end
+        check
+      end
+
+      # Output the plain text response from calling all the filters.
+      def render(statuses, elapsed_time) #:nodoc:
+        fail = statuses.all?{|s| s.success?}
+        headers = {
+          "Content-Type" => "text/plain; charset=utf8",
+          "Cache-Control" => "no-cache",
+          "Date" => Time.now.httpdate,
+        }
+        
+        messages = []
+        statuses.each do |status|
+          status.messages.each do |m|
+            messages << "#{m.ok? ? 'OK:  ' : 'FAIL:'} #{status.name} - #{m.message} (#{status.time ? sprintf('%0.000f', status.time * 1000) : '?'}ms)"
+          end
+        end
+        
+        info = []
+        info << "Host: #{@hostname}" unless @hostname.size == 0
+        info << "PID:  #{$$}"
+        info << "Timestamp: #{Time.now.iso8601}"
+        info << "Elapsed Time: #{(elapsed_time * 1000).round}ms"
+        
+        code = (fail ? 200 : 500)
+        
+        [code, headers, [info.join("\n"), "\n\n", messages.join("\n")]]
+      end
+  end
+end

data/lib/is_it_working/status.rb

@@ -0,0 +1,50 @@
+module IsItWorking
+  # This class is used to pass the status of a monitoring check. Each status can have multiple
+  # messages added to it by calling the +ok+ or +fail+ methods. The status check will only be
+  # considered a success if all messages are ok.
+  class Status
+    # This class is used to contain individual status messages. Eache method can represent either
+    # and +ok+ message or a +fail+ message.
+    class Message
+      attr_reader :message
+
+      def initialize(message, ok)
+        @message = message
+        @ok = ok
+      end
+
+      def ok?
+        @ok
+      end
+    end
+
+    # The name of the status check for display purposes.
+    attr_reader :name
+
+    # The messages set on the status check.
+    attr_reader :messages
+
+    # The amount of time it takes to complete the status check.
+    attr_accessor :time
+
+    def initialize(name)
+      @name = name
+      @messages = []
+    end
+
+    # Add a message indicating that the check passed.
+    def ok(message)
+      @messages << Message.new(message, true)
+    end
+
+    # Add a message indicating that the check failed.
+    def fail(message)
+      @messages << Message.new(message, false)
+    end
+
+    # Returns +true+ only if all checks were OK.
+    def success?
+      @messages.all?{|m| m.ok?}
+    end
+  end
+end

data/spec/action_mailer_check_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe IsItWorking::ActionMailerCheck do
+
+  let(:status){ IsItWorking::Status.new(:ping) }
+  
+  it "should succeed if the default mail host is accepting connections" do
+    ActionMailer::Base.smtp_settings[:address] = 'localhost'
+    ActionMailer::Base.smtp_settings[:port] = 25
+    TCPSocket.should_receive(:new).with('localhost', 25).and_return(mock(:socket, :close => true))
+    check = IsItWorking::ActionMailerCheck.new
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "ActionMailer::Base is accepting connections on port 25"
+  end
+  
+  it "should succeed if the default mail host is not accepting connections" do
+    ActionMailer::Base.smtp_settings[:address] = 'localhost'
+    ActionMailer::Base.smtp_settings[:port] = 25
+    TCPSocket.should_receive(:new).with('localhost', 25).and_raise(Errno::ECONNREFUSED)
+    check = IsItWorking::ActionMailerCheck.new
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "ActionMailer::Base is not accepting connections on port 25"
+  end
+  
+  it "should get the smtp configuration from a specified ActionMailer class" do
+    class IsItWorking::ActionMailerCheck::Tester < ActionMailer::Base
+    end
+    
+    IsItWorking::ActionMailerCheck::Tester.smtp_settings[:address] = 'mail.example.com'
+    IsItWorking::ActionMailerCheck::Tester.smtp_settings[:port] = 'smtp'
+    TCPSocket.should_receive(:new).with('mail.example.com', 'smtp').and_return(mock(:socket, :close => true))
+    check = IsItWorking::ActionMailerCheck.new(:class => IsItWorking::ActionMailerCheck::Tester)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "IsItWorking::ActionMailerCheck::Tester is accepting connections on port \"smtp\""
+  end
+  
+  it "should allow aliasing the ActionMailer host alias" do
+    ActionMailer::Base.smtp_settings[:address] = 'localhost'
+    ActionMailer::Base.smtp_settings[:port] = 25
+    TCPSocket.should_receive(:new).with('localhost', 25).and_return(mock(:socket, :close => true))
+    check = IsItWorking::ActionMailerCheck.new(:alias => "smtp host")
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "smtp host is accepting connections on port 25"
+  end
+  
+  
+end

data/spec/active_record_check_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe IsItWorking::ActiveRecordCheck do
+
+  let(:status){ IsItWorking::Status.new(:active_record) }
+
+  class IsItWorking::TestActiveRecord < ActiveRecord::Base
+  end
+  
+  it "should succeed if the ActiveRecord connection is active" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.reconnect!
+    ActiveRecord::Base.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "ActiveRecord::Base.connection is active"
+  end
+  
+  it "should allow specifying the class to check the connection for" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.reconnect!
+    IsItWorking::TestActiveRecord.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new(:class => IsItWorking::TestActiveRecord)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "IsItWorking::TestActiveRecord.connection is active"
+  end
+
+  it "should succeed if the ActiveRecord connection can be reconnected" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.disconnect!
+    ActiveRecord::Base.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "ActiveRecord::Base.connection is active"
+  end
+
+  it "should fail if the ActiveRecord connection is not active" do
+    connection = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(mock(:connection))
+    connection.disconnect!
+    connection.stub!(:verify!)
+    ActiveRecord::Base.stub!(:connection).and_return(connection)
+    check = IsItWorking::ActiveRecordCheck.new
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "ActiveRecord::Base.connection is not active"
+  end
+  
+end

data/spec/dalli_check_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe IsItWorking::DalliCheck do
+
+  let(:status){ IsItWorking::Status.new(:memcache) }
+  let(:memcache){ Dalli::Client.new(['cache-1.example.com', 'cache-2.example.com']) }
+  let(:servers){ memcache.send(:ring).servers }
+
+  it "should succeed if all servers are responding" do
+    check = IsItWorking::DalliCheck.new(:cache => memcache)
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(true)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "cache-1.example.com:11211 is available"
+    status.messages.last.message.should == "cache-2.example.com:11211 is available"
+  end
+
+  it "should fail if any server is not responding" do
+    check = IsItWorking::DalliCheck.new(:cache => memcache)
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(false)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should == "cache-1.example.com:11211 is available"
+    status.messages.last.message.should == "cache-2.example.com:11211 is not available"
+  end
+
+  it "should be able to get the MemCache object from an ActiveSupport::Cache" do
+    require 'active_support/cache'
+    require 'active_support/cache/dalli_store'
+    ActiveSupport::Cache::DalliStore.should_receive(:new).with('cache-1.example.com', 'cache-2.example.com').and_return(memcache)
+    rails_cache = ActiveSupport::Cache::DalliStore.new('cache-1.example.com', 'cache-2.example.com')
+    check = IsItWorking::DalliCheck.new(:cache => rails_cache)
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(true)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "cache-1.example.com:11211 is available"
+    status.messages.last.message.should == "cache-2.example.com:11211 is available"
+  end
+
+  it "should be able to alias the memcache host names in the output" do
+    check = IsItWorking::DalliCheck.new(:cache => memcache, :alias => "memcache")
+    servers.first.should_receive(:alive?).and_return(true)
+    servers.last.should_receive(:alive?).and_return(true)
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should == "memcache 1 is available"
+    status.messages.last.message.should == "memcache 2 is available"
+  end
+
+end

data/spec/directory_check_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe IsItWorking::DirectoryCheck do
+  
+  let(:status){ IsItWorking::Status.new(:directory) }
+  let(:directory_path){ File.expand_path(".") }
+  
+  it "should fail if a directory can't be found" do
+    check = IsItWorking::DirectoryCheck.new(:path => File.expand_path("../no_such_thing", __FILE__))
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("does not exist")
+  end
+  
+  it "should fail if a path isn't a directory" do
+    check = IsItWorking::DirectoryCheck.new(:path => __FILE__)
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("is not a directory")
+  end
+  
+  it "should succeed if a directory exists" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => false, :writable? => false))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists")
+  end
+  
+  it "should fail if a directory is not readable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :read)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => false, :writable? => true))
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("is not readable")
+  end
+  
+  it "should fail if a directory is not writable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :write)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => true, :writable? => false))
+    check.call(status)
+    status.should_not be_success
+    status.messages.first.message.should include("is not writable")
+  end
+  
+  it "should succeed if a directory exists and is readable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :read)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => true, :writable? => false))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists with")
+  end
+  
+  it "should succeed if a directory exists and is writable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => :write)
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => false, :writable? => true))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists with")
+  end
+  
+  it "should succeed if a directory exists and is readable and writable" do
+    check = IsItWorking::DirectoryCheck.new(:path => directory_path, :permission => [:read, :write])
+    File.should_receive(:stat).with(directory_path).and_return(mock(:stat, :directory? => true, :readable? => true, :writable? => true))
+    check.call(status)
+    status.should be_success
+    status.messages.first.message.should include("exists with")
+  end
+  
+end