rails_health_check 3.0.0

data/lib/health_check/health_check_controller.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2010-2013 Ian Heggie, released under the MIT license.
+# See MIT-LICENSE for details.
+
+module HealthCheck
+  class HealthCheckController < ActionController::Base
+
+    layout false if self.respond_to? :layout
+    before_action :check_origin_ip
+    before_action :authenticate
+
+    def index
+      last_modified = Time.now.utc
+      max_age = HealthCheck.max_age
+      if max_age > 1
+        last_modified = Time.at((last_modified.to_f / max_age).floor * max_age).utc
+      end
+      public = (max_age > 1) && ! HealthCheck.basic_auth_username
+      if stale?(:last_modified => last_modified, :public => public)
+        checks = params[:checks] ? params[:checks].split('_') : ['standard']
+        checks -= HealthCheck.middleware_checks if HealthCheck.installed_as_middleware
+        begin
+          errors = HealthCheck::Utils.process_checks(checks)
+        rescue Exception => e
+          errors = e.message.blank? ? e.class.to_s : e.message.to_s
+        end
+        response.headers['Cache-control'] = (public ? 'public' : 'private') + ', no-cache, must-revalidate' + (max_age > 0 ? ", max-age=#{max_age}" : '')
+        if errors.blank?
+          send_response true, nil, :ok, :ok
+        else
+          msg = HealthCheck.include_error_in_response_body ? "health_check failed: #{errors}" : nil
+          send_response false, msg, HealthCheck.http_status_for_error_text, HealthCheck.http_status_for_error_object
+          # Log a single line as some uptime checkers only record that it failed, not the text returned
+          if logger
+            logger.info msg
+          end
+        end
+      end
+    end
+
+    protected
+
+    def send_response(healthy, msg, text_status, obj_status)
+      msg ||= healthy ? HealthCheck.success : HealthCheck.failure
+      obj = { :healthy => healthy, :message => msg}
+      respond_to do |format|
+        format.html { render :plain => msg, :status => text_status, :content_type => 'text/plain' }
+        format.json { render :json => obj, :status => obj_status }
+        format.xml { render :xml => obj, :status => obj_status }
+        format.any { render :plain => msg, :status => text_status, :content_type => 'text/plain' }
+      end
+    end
+
+    def authenticate
+      return unless HealthCheck.basic_auth_username && HealthCheck.basic_auth_password
+      authenticate_or_request_with_http_basic('Health Check') do |username, password|
+        username == HealthCheck.basic_auth_username && password == HealthCheck.basic_auth_password
+      end
+    end
+
+    def check_origin_ip
+      unless HealthCheck.origin_ip_whitelist.blank? ||
+          HealthCheck.origin_ip_whitelist.include?(request.ip)
+        render :plain => 'Health check is not allowed for the requesting IP',
+               :status => HealthCheck.http_status_for_ip_whitelist_error,
+               :content_type => 'text/plain'
+      end
+    end
+
+    # turn cookies for CSRF off
+    def protect_against_forgery?
+      false
+    end
+
+  end
+end

data/lib/health_check/health_check_routes.rb

@@ -0,0 +1,15 @@
+module ActionDispatch::Routing
+  class Mapper
+
+    def health_check_routes(prefix = nil)
+      HealthCheck::Engine.routes_explicitly_defined = true
+      add_health_check_routes(prefix)
+    end
+
+    def add_health_check_routes(prefix = nil)
+      HealthCheck.uri = prefix if prefix
+      match "#{HealthCheck.uri}(/:checks)(.:format)", :to => 'health_check/health_check#index', via: [:get, :post], :defaults => { :format => 'txt' }
+    end
+
+  end
+end

data/lib/health_check/middleware_health_check.rb

@@ -0,0 +1,102 @@
+module HealthCheck
+  class MiddlewareHealthcheck
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      (response_type, middleware_checks, full_stack_checks) = parse_env(env)
+      if response_type
+        if error_response = (ip_blocked(env) || not_authenticated(env))
+          return error_response
+        end
+        HealthCheck.installed_as_middleware = true
+        errors = ''
+        begin
+          # Process the checks to be run from middleware
+          errors = HealthCheck::Utils.process_checks(middleware_checks, true)
+          # Process remaining checks through the full stack if there are any
+          unless full_stack_checks.empty?
+            return @app.call(env)
+          end
+        rescue => e
+          errors = e.message.blank? ? e.class.to_s : e.message.to_s
+        end
+        healthy = errors.blank?
+        msg = healthy ? HealthCheck.success : "health_check failed: #{errors}"
+        if response_type == 'xml'
+          content_type = 'text/xml'
+          msg = { healthy: healthy, message: msg }.to_xml
+          error_code = HealthCheck.http_status_for_error_object
+        elsif response_type == 'json'
+          content_type = 'application/json'
+          msg = { healthy: healthy, message: msg }.to_json
+          error_code = HealthCheck.http_status_for_error_object
+        else
+          content_type = 'text/plain'
+          error_code = HealthCheck.http_status_for_error_text
+        end
+        [ (healthy ? 200 : error_code), { 'Content-Type' => content_type }, [msg] ]
+      else
+        @app.call(env)
+      end
+    end
+
+    protected
+
+    def parse_env(env)
+      uri = env['PATH_INFO']
+      if uri =~ /^\/#{Regexp.escape HealthCheck.uri}(\/([-_0-9a-zA-Z]*))?(\.(\w*))?$/
+        checks = $2.to_s == '' ? ['standard'] : $2.split('_')
+        response_type = $4.to_s
+        middleware_checks = checks & HealthCheck.middleware_checks
+        full_stack_checks = (checks - HealthCheck.middleware_checks) - ['and']
+        [response_type, middleware_checks, full_stack_checks ]
+      end
+    end
+
+    def ip_blocked(env)
+      return false if HealthCheck.origin_ip_whitelist.blank?
+      req = Rack::Request.new(env)
+      unless HealthCheck.origin_ip_whitelist.include?(req.ip)
+        [ HealthCheck.http_status_for_ip_whitelist_error,
+          { 'Content-Type' => 'text/plain' },
+          [ 'Health check is not allowed for the requesting IP' ]
+        ]
+      end
+    end
+
+    def not_authenticated(env)
+      return false unless HealthCheck.basic_auth_username && HealthCheck.basic_auth_password
+      auth = MiddlewareHealthcheck::Request.new(env)
+      if auth.provided? && auth.basic? && Rack::Utils.secure_compare(HealthCheck.basic_auth_username, auth.username) && Rack::Utils.secure_compare(HealthCheck.basic_auth_password, auth.password)
+        env['REMOTE_USER'] = auth.username
+        return false
+      end
+      [ 401,
+        { 'Content-Type' => 'text/plain', 'WWW-Authenticate' => 'Basic realm="Health Check"' },
+        [ ]
+      ]
+    end
+
+    class Request < Rack::Auth::AbstractRequest
+      def basic?
+        "basic" == scheme
+      end
+
+      def credentials
+        @credentials ||= params.unpack("m*").first.split(/:/, 2)
+      end
+
+      def username
+        credentials.first
+      end
+
+      def password
+        credentials.last
+      end
+    end
+
+  end
+end

data/lib/health_check/redis_health_check.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module HealthCheck
+  class RedisHealthCheck
+    extend BaseHealthCheck
+
+    class << self
+      def check
+        raise "Wrong configuration. Missing 'redis' gem" unless defined?(::Redis)
+
+        client.ping == 'PONG' ? '' : "Redis.ping returned #{res.inspect} instead of PONG"
+      rescue Exception => err
+        create_error 'redis', err.message
+      ensure
+        client.disconnect
+      end
+
+      def client
+        Redis.new(url: HealthCheck.redis_url)
+      end
+    end
+  end
+end

data/lib/health_check/resque_health_check.rb

@@ -0,0 +1,15 @@
+module HealthCheck
+   class ResqueHealthCheck
+     extend BaseHealthCheck
+
+     def self.check
+       unless defined?(::Resque)
+         raise "Wrong configuration. Missing 'resque' gem"
+       end
+      res = ::Resque.redis.ping
+      res == 'PONG' ? '' : "Resque.redis.ping returned #{res.inspect} instead of PONG"
+     rescue Exception => e
+       create_error 'resque-redis', e.message
+     end
+   end
+end

data/lib/health_check/s3_health_check.rb

@@ -0,0 +1,65 @@
+module HealthCheck
+  class S3HealthCheck
+    extend BaseHealthCheck
+
+    class << self
+      def check
+        unless defined?(::Aws)
+          raise "Wrong configuration. Missing 'aws-sdk' gem"
+        end
+        return create_error 's3', 'Could not connect to aws' if aws_s3_client.nil?
+        HealthCheck.buckets.each do |bucket_name, permissions|
+          if permissions.nil? # backward compatible
+            permissions = [:R, :W, :D]
+          end
+          permissions.each do |permision|
+            begin
+            send(permision, bucket_name)
+          rescue Exception => e
+            raise "bucket:#{bucket_name}, permission:#{permision} - #{e.message}"
+          end
+          end
+        end
+        ''
+      rescue Exception => e
+        create_error 's3', e.message
+      end
+
+      private
+
+      def configure_client
+        return unless defined?(Rails)
+
+        aws_configuration = {
+          region: Rails.application.secrets.aws_default_region,
+          credentials: ::Aws::Credentials.new(
+            Rails.application.secrets.aws_access_key_id,
+            Rails.application.secrets.aws_secret_access_key
+          ),
+          force_path_style: true
+        }
+
+        ::Aws::S3::Client.new aws_configuration
+      end
+
+      def aws_s3_client
+        @aws_s3_client ||= configure_client
+      end
+
+      def R(bucket)
+        aws_s3_client.list_objects(bucket: bucket)
+      end
+
+      def W(bucket)
+        aws_s3_client.put_object(bucket: bucket,
+                                 key: "healthcheck_#{Rails.application.class.parent_name}",
+                                 body: Time.new.to_s)
+      end
+
+      def D(bucket)
+        aws_s3_client.delete_object(bucket: bucket,
+                                    key: "healthcheck_#{Rails.application.class.parent_name}")
+      end
+    end
+  end
+end

data/lib/health_check/sidekiq_health_check.rb

@@ -0,0 +1,17 @@
+module HealthCheck
+  class SidekiqHealthCheck
+    extend BaseHealthCheck
+
+    def self.check
+      unless defined?(::Sidekiq)
+        raise "Wrong configuration. Missing 'sidekiq' gem"
+      end
+      ::Sidekiq.redis do |r|
+        res = r.ping
+        res == 'PONG' ? '' : "Sidekiq.redis.ping returned #{res.inspect} instead of PONG"
+      end
+    rescue Exception => e
+      create_error 'sidekiq-redis', e.message
+    end
+  end
+end

data/lib/health_check/utils.rb

@@ -0,0 +1,171 @@
+# Copyright (c) 2010-2013 Ian Heggie, released under the MIT license.
+# See MIT-LICENSE for details.
+
+module HealthCheck
+  class Utils
+
+    @@default_smtp_settings =
+        {
+            :address              => "localhost",
+            :port                 => 25,
+            :domain               => 'localhost.localdomain',
+            :user_name            => nil,
+            :password             => nil,
+            :authentication       => nil,
+            :enable_starttls_auto => true,
+        }
+
+    cattr_accessor :default_smtp_settings
+
+    # process an array containing a list of checks
+    def self.process_checks(checks, called_from_middleware = false)
+      errors = ''
+      checks.each do |check|
+        case check
+          when 'and', 'site'
+            # do nothing
+          when "database"
+            HealthCheck::Utils.get_database_version
+          when "email"
+            errors << HealthCheck::Utils.check_email
+          when "emailconf"
+            errors << HealthCheck::Utils.check_email if HealthCheck::Utils.mailer_configured?
+          when "migrations", "migration"
+            if defined?(ActiveRecord::Migration) and ActiveRecord::Migration.respond_to?(:check_pending!)
+              # Rails 4+
+              begin
+                ActiveRecord::Migration.check_pending!
+              rescue ActiveRecord::PendingMigrationError => ex
+                  errors << ex.message
+              end
+            else
+              database_version  = HealthCheck::Utils.get_database_version
+              migration_version = HealthCheck::Utils.get_migration_version
+              if database_version.to_i != migration_version.to_i
+                errors << "Current database version (#{database_version}) does not match latest migration (#{migration_version}). "
+              end
+            end
+          when 'cache'
+            errors << HealthCheck::Utils.check_cache
+          when 'resque-redis-if-present'
+            errors << HealthCheck::ResqueHealthCheck.check if defined?(::Resque)
+          when 'sidekiq-redis-if-present'
+            errors << HealthCheck::SidekiqHealthCheck.check if defined?(::Sidekiq)
+          when 'redis-if-present'
+            errors << HealthCheck::RedisHealthCheck.check if defined?(::Redis)
+          when 's3-if-present'
+            errors << HealthCheck::S3HealthCheck.check if defined?(::Aws)
+          when 'resque-redis'
+            errors << HealthCheck::ResqueHealthCheck.check
+          when 'sidekiq-redis'
+            errors << HealthCheck::SidekiqHealthCheck.check
+          when 'redis'
+            errors << HealthCheck::RedisHealthCheck.check
+          when 's3'
+            errors << HealthCheck::S3HealthCheck.check
+          when "standard"
+            errors << HealthCheck::Utils.process_checks(HealthCheck.standard_checks, called_from_middleware)
+          when "middleware"
+            errors << "Health check not called from middleware - probably not installed as middleware." unless called_from_middleware
+          when "custom"
+            HealthCheck.custom_checks.each do |name, list|
+              list.each do |custom_check|
+                errors << custom_check.call(self)
+              end
+            end
+          when "all", "full"
+            errors << HealthCheck::Utils.process_checks(HealthCheck.full_checks, called_from_middleware)
+          else
+            if HealthCheck.custom_checks.include? check
+               HealthCheck.custom_checks[check].each do |custom_check|
+                 errors << custom_check.call(self)
+               end
+            else
+              return "invalid argument to health_test."
+            end
+        end
+      end
+      return errors
+    rescue => e
+      return e.message
+    end
+
+    def self.db_migrate_path
+      # Lazy initialisation so Rails.root will be defined
+      @@db_migrate_path ||= File.join(Rails.root, 'db', 'migrate')
+    end
+
+    def self.db_migrate_path=(value)
+      @@db_migrate_path = value
+    end
+
+    def self.mailer_configured?
+      defined?(ActionMailer::Base) && (ActionMailer::Base.delivery_method != :smtp || HealthCheck::Utils.default_smtp_settings != ActionMailer::Base.smtp_settings)
+    end
+
+    def self.get_database_version
+      ActiveRecord::Migrator.current_version if defined?(ActiveRecord)
+    end
+
+    def self.get_migration_version(dir = self.db_migrate_path)
+      latest_migration = nil
+      Dir[File.join(dir, "[0-9]*_*.rb")].each do |f|
+        l = f.scan(/0*([0-9]+)_[_.a-zA-Z0-9]*.rb/).first.first rescue -1
+        latest_migration = l if !latest_migration || l.to_i > latest_migration.to_i
+      end
+      latest_migration
+    end
+
+    def self.check_email
+      case ActionMailer::Base.delivery_method
+        when :smtp
+          HealthCheck::Utils.check_smtp(ActionMailer::Base.smtp_settings, HealthCheck.smtp_timeout)
+        when :sendmail
+          HealthCheck::Utils.check_sendmail(ActionMailer::Base.sendmail_settings)
+        else
+          ''
+      end
+    end
+
+    def self.check_sendmail(settings)
+      File.executable?(settings[:location]) ? '' : 'no sendmail executable found. '
+    end
+
+    def self.check_smtp(settings, timeout)
+      status = ''
+      begin
+        if @skip_external_checks
+          status = '221'
+        else
+          Timeout::timeout(timeout) do |timeout_length|
+            t = TCPSocket.new(settings[:address], settings[:port])
+            begin
+              status = t.gets
+              while status != nil && status !~ /^2/
+                status = t.gets
+              end
+              t.puts "HELO #{settings[:domain]}\r"
+              while status != nil && status !~ /^250/
+                status = t.gets
+              end
+              t.puts "QUIT\r"
+              status = t.gets
+            ensure
+              t.close
+            end
+          end
+        end
+      rescue Errno::EBADF => ex
+        status = "Unable to connect to service"
+      rescue Exception => ex
+        status = ex.to_s
+      end
+      (status =~ /^221/) ? '' : "SMTP: #{status || 'unexpected EOF on socket'}. "
+    end
+
+    def self.check_cache
+      Rails.cache.write('__health_check_cache_test__', 'ok', :expires_in => 1.second) ? '' : 'Unable to write to cache. '
+    end
+
+  end
+end

data/lib/health_check/version.rb

@@ -0,0 +1,3 @@
+module HealthCheck
+  VERSION = "3.0.0"
+end

data/lib/health_check.rb

@@ -0,0 +1,101 @@
+# Copyright (c) 2010-2013 Ian Heggie, released under the MIT license.
+# See MIT-LICENSE for details.
+
+module HealthCheck
+
+  class Engine < Rails::Engine
+    cattr_accessor :routes_explicitly_defined 
+  end
+
+  # Text output upon success
+  mattr_accessor :success
+  self.success = "success"
+
+  # Text output upon failure
+  mattr_accessor :failure
+  self.failure = "failure"
+
+  # Timeout in seconds used when checking smtp server
+  mattr_accessor :smtp_timeout
+  self.smtp_timeout = 30.0
+
+  # http status code used when plain text error message is output
+  mattr_accessor :http_status_for_error_text
+  self.http_status_for_error_text = 500
+
+  # http status code used when an error object is output (json or xml)
+  mattr_accessor :http_status_for_error_object
+  self.http_status_for_error_object = 500
+
+  # http status code used when the ip is not allowed for the request
+  mattr_accessor :http_status_for_ip_whitelist_error
+  self.http_status_for_ip_whitelist_error = 403
+
+  # ips allowed to perform requests
+  mattr_accessor :origin_ip_whitelist
+  self.origin_ip_whitelist = []
+
+  # max-age of response in seconds
+  # cache-control is public when max_age > 1 and basic authentication is used
+  mattr_accessor :max_age
+  self.max_age = 1
+
+  # s3 buckets
+  mattr_accessor :buckets
+  self.buckets = {}
+
+  # health check uri path
+  mattr_accessor :uri
+  self.uri = 'health_check'
+
+  # Basic Authentication
+  mattr_accessor :basic_auth_username, :basic_auth_password
+  self.basic_auth_username = nil
+  self.basic_auth_password = nil
+
+  # Array of custom check blocks
+  mattr_accessor :custom_checks
+  mattr_accessor :full_checks
+  mattr_accessor :standard_checks
+  self.custom_checks = { }
+  self.full_checks = ['database', 'migrations', 'custom', 'email', 'cache', 'redis-if-present', 'sidekiq-redis-if-present', 'resque-redis-if-present', 's3-if-present']
+  self.standard_checks = [ 'database', 'migrations', 'custom', 'emailconf' ]
+
+  # Middleware based checks
+  mattr_accessor :middleware_checks
+  self.middleware_checks = [ 'middleware' ]
+
+  mattr_accessor :installed_as_middleware
+
+  # Allow non-standard redis url
+  mattr_accessor :redis_url
+  self.redis_url = nil
+
+  # Include the error in the response body. You may want to set this to false
+  # if your /health_check endpoint is open to the public internet
+  mattr_accessor :include_error_in_response_body
+  self.include_error_in_response_body = true
+
+  def self.add_custom_check(name = 'custom', &block)
+    custom_checks[name] ||= [ ]
+    custom_checks[name] << block
+  end
+
+  def self.setup
+    yield self
+  end
+
+end
+
+require 'health_check/version'
+require 'health_check/base_health_check'
+require 'health_check/resque_health_check'
+require 'health_check/s3_health_check'
+require 'health_check/redis_health_check'
+require 'health_check/sidekiq_health_check'
+require 'health_check/utils'
+require 'health_check/health_check_controller'
+require 'health_check/health_check_routes'
+require 'health_check/middleware_health_check'
+
+# vi: sw=2 sm ai:

data/test/fake_smtp_server

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+port = 3555
+
+
+server = TCPServer.new port
+puts "fake_smtp_server: Waiting for one connection to port #{port} ..."
+
+def send(client, line)
+  client.puts line
+  puts "> #{line}"
+end
+
+def receive(client)
+  line = client.gets
+  puts "< #{line}"
+  line
+end
+
+client = server.accept    # Wait for a client to connect
+send(client, "220 dummy-smtp.example.com SMTP")
+cmd = receive(client)
+
+while cmd !~ /^QUIT\r/
+  if cmd =~ /^HELO(.*)\r/
+    send(client, "250 Welcome to a dummy smtp server")
+  else
+    send(client, "502 I am so dumb I only understand HELO and QUIT")
+  end
+  cmd = receive(client)
+end
+send(client, "221 Bye Bye")
+
+client.close
+puts "fake_smtp_server: Exiting now the conversation has finished."
+exit 0

data/test/init_variables

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# Any failure causes exit
+set -e
+
+echo Setting RAILS_ENV=test RACK_ENV=test
+export RAILS_ENV=test RACK_ENV=test
+
+base_dir=$PWD
+tmp_dir=$base_dir/tmp
+railsapp=$tmp_dir/railsapp
+custom_file="$railsapp/tmp/custom_check.ok"
+catchall_file="$railsapp/tmp/catchall_route.enabled"
+success=successful
+
+rehash=''
+rbenv_which='which'
+
+if [[ -s "$HOME/.rvm/scripts/rvm" ]] ; then
+  echo "Detected user installed rvm"
+elif [[ -s "/usr/local/rvm/scripts/rvm" ]] ; then
+  echo "Detected root installed rvm"
+elif [[ -d "$HOME/.rbenv" ]] ; then
+  echo "Detected rbenv: `rbenv version`"
+  rehash='rbenv rehash'
+  rbenv_which='rbenv which'
+else
+  printf "Note: Neither rvm nor rbenv was not found.\n"
+fi
+
+echo "Checking required commands exist:"
+for cmd in bash gem egrep ls tail kill find cpio
+do
+    echo -n "  "
+    which $cmd || ( echo "Aborting setup_railsapp: Missing $cmd command!" && exit 2 )
+done
+for cmd in ruby gem
+do
+    echo -n "  "
+    $rbenv_which $cmd || ( echo "Aborting setup_railsapp: Missing $cmd command!" && exit 2 )
+done
+
+rails="rails"
+rake="rake"
+
+if [ -x $base_dir/test/bin/rails ]
+then
+    rails="$base_dir/test/bin/rails"
+    rake="$base_dir/test/bin/rake"
+    export PATH="$base_dir/test/bin:$PATH"
+fi
+
+if [ -x $railsapp/bin/rails ]
+then
+    rails="$railsapp/bin/rails"
+    rake="$railsapp/bin/rake"
+    export PATH="$railsapp/bin:$PATH"
+fi
+
+echo "Using rails=$rails, rake=$rake"
+