health_check 3.0.0 → 3.1.0

data/Rakefile

@@ -8,7 +8,7 @@ task :test do
   exec '/bin/bash', './test/test_with_railsapp'
 end
 
-task :default => :test
+task default: :test
 
 begin
   gem 'rdoc'

data/Vagrantfile

@@ -5,7 +5,7 @@ Vagrant.configure("2") do |config|
   # For a complete reference, please see the online documentation at
   # https://docs.vagrantup.com.
 
-  config.vm.box = "ubuntu/xenial64"
+  config.vm.box = "ubuntu/focal64"
 
   # set auto_update to false, if you do NOT want to check the correct 
   # additions version when booting this machine
@@ -17,4 +17,16 @@ Vagrant.configure("2") do |config|
   # provision with a shell script.
   config.vm.provision "shell", path: "./test/provision_vagrant"
 
+  config.vm.provider "virtualbox" do |v|
+    # travis allocates 7.5 GB, but this is sufficient
+    v.memory = 2048
+    v.cpus = 2
+  end
+
+#  if File.file?('.git') && IO.read('.git') =~ %r{\Agitdir: (.+)/.git/worktrees.*}
+#    # Handle git worktrees ...
+#    path = $1
+#    config.vm.synced_folder path, path
+#  end
+
 end

data/config/routes.rb

@@ -1,5 +1,5 @@
 unless HealthCheck::Engine.routes_explicitly_defined
-  Rails.application.routes.draw do
+  ::Rails.application.routes.draw do
     add_health_check_routes()
   end
 end

data/health_check.gemspec

@@ -9,14 +9,14 @@ Gem::Specification.new do |gem|
   gem.required_rubygems_version = Gem::Requirement.new(">= 0") if gem.respond_to? :required_rubygems_version=
   gem.authors       = ["Ian Heggie"]
   gem.email         = ["ian@heggie.biz"]
-  gem.summary = %q{Simple health check of Rails app for uptime monitoring with Pingdom, NewRelic, EngineYard or uptime.openacs.org etc.}
+  gem.summary = %q{Simple health check of Rails app for uptime monitoring with Pingdom, NewRelic, EngineYard etc.}
   gem.description = <<-EOF
-  	Simple health check of Rails app for uptime monitoring with Pingdom, NewRelic, EngineYard or uptime.openacs.org etc.
+  	Simple health check of Rails app for uptime monitoring with Pingdom, NewRelic, EngineYard etc.
   EOF
   gem.homepage      = "https://github.com/ianheggie/health_check"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.extra_rdoc_files = [ "README.rdoc" ]
   gem.require_paths = ["lib"]
@@ -25,5 +25,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency(%q<smarter_bundler>, [">= 0.1.0"])
   gem.add_development_dependency(%q<rake>, [">= 0.8.3"])
   gem.add_development_dependency(%q<shoulda>, ["~> 2.11.0"])
-  gem.add_development_dependency(%q<bundler>, ["~> 1.2"])
+  gem.add_development_dependency(%q<bundler>, [">= 1.2"])
 end

data/lib/health_check.rb

@@ -3,14 +3,22 @@
 
 module HealthCheck
 
-  class Engine < Rails::Engine
-    cattr_accessor :routes_explicitly_defined 
+  class Engine < ::Rails::Engine
+    cattr_accessor :routes_explicitly_defined
   end
 
+  # Log level
+  mattr_accessor :log_level
+  self.log_level = 'info'
+
   # Text output upon success
   mattr_accessor :success
   self.success = "success"
 
+  # Text output upon failure
+  mattr_accessor :failure
+  self.failure = "health_check failed"
+
   # Timeout in seconds used when checking smtp server
   mattr_accessor :smtp_timeout
   self.smtp_timeout = 30.0
@@ -27,6 +35,10 @@ module HealthCheck
   mattr_accessor :http_status_for_ip_whitelist_error
   self.http_status_for_ip_whitelist_error = 403
 
+  # check remote_ip rather than ip for ip whitelist
+  mattr_accessor :accept_proxied_requests
+  self.accept_proxied_requests = false
+
   # ips allowed to perform requests
   mattr_accessor :origin_ip_whitelist
   self.origin_ip_whitelist = []
@@ -40,6 +52,10 @@ module HealthCheck
   mattr_accessor :buckets
   self.buckets = {}
 
+  # rabbitmq
+  mattr_accessor :rabbitmq_config
+  self.rabbitmq_config = {}
+
   # health check uri path
   mattr_accessor :uri
   self.uri = 'health_check'
@@ -54,7 +70,7 @@ module HealthCheck
   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.full_checks = ['database', 'migrations', 'custom', 'email', 'cache', 'redis-if-present', 'sidekiq-redis-if-present', 'resque-redis-if-present', 's3-if-present', 'elasticsearch-if-present']
   self.standard_checks = [ 'database', 'migrations', 'custom', 'emailconf' ]
 
   # Middleware based checks
@@ -63,15 +79,37 @@ module HealthCheck
 
   mattr_accessor :installed_as_middleware
 
-  # Allow non-standard redis url
+  # Allow non-standard redis url and password
   mattr_accessor :redis_url
-  self.redis_url = nil
+  self.redis_url = ENV['REDIS_URL']
+
+  mattr_accessor :redis_password
+  self.redis_password = 'some-password'
+
+  # Include the error in the response body. 
+  # You should only do this where your /health_check endpoint is NOT open to the public internet
+  mattr_accessor :include_error_in_response_body
+  self.include_error_in_response_body = false
+
+  # used for on_failure and on_success
+  mattr_accessor :success_callbacks
+  mattr_accessor :failure_callbacks
 
   def self.add_custom_check(name = 'custom', &block)
     custom_checks[name] ||= [ ]
     custom_checks[name] << block
   end
 
+  def self.on_success(&block)
+    success_callbacks ||= [ ]
+    success_callbacks << block
+  end
+
+  def self.on_failure(&block)
+    failure_callbacks ||= [ ]
+    failure_callbacks << block
+  end
+
   def self.setup
     yield self
   end
@@ -83,10 +121,12 @@ 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/elasticsearch_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'
+require 'health_check/rabbitmq_health_check'
 
 # vi: sw=2 sm ai:

data/lib/health_check/elasticsearch_health_check.rb

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

data/lib/health_check/health_check_controller.rb

@@ -1,5 +1,6 @@
-# Copyright (c) 2010-2013 Ian Heggie, released under the MIT license.
+# Copyright (c) 2010-2021 Ian Heggie, released under the MIT license.
 # See MIT-LICENSE for details.
+require "ipaddr"
 
 module HealthCheck
   class HealthCheckController < ActionController::Base
@@ -14,8 +15,8 @@ module HealthCheck
       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)
+      is_public = (max_age > 1) && ! HealthCheck.basic_auth_username
+      if stale?(last_modified: last_modified, public: is_public)
         checks = params[:checks] ? params[:checks].split('_') : ['standard']
         checks -= HealthCheck.middleware_checks if HealthCheck.installed_as_middleware
         begin
@@ -23,15 +24,25 @@ module HealthCheck
         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}" : '')
+        response.headers['Cache-Control'] = "must-revalidate, max-age=#{max_age}"
         if errors.blank?
-          send_response nil, :ok, :ok
+          send_response true, nil, :ok, :ok
+          if HealthCheck.success_callbacks
+            HealthCheck.success_callbacks.each do |callback|
+              callback.call(checks)
+            end 
+          end
         else
-          msg = "health_check failed: #{errors}"
-          send_response msg, HealthCheck.http_status_for_error_text, HealthCheck.http_status_for_error_object
+          msg = HealthCheck.include_error_in_response_body ? "#{HealthCheck.failure}: #{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
+          msg = "#{HealthCheck.failure}: #{errors}"
+          logger.send(HealthCheck.log_level, msg) if logger && HealthCheck.log_level
+          if HealthCheck.failure_callbacks
+            HealthCheck.failure_callbacks.each do |callback|
+              callback.call(checks, msg)
+            end
           end
         end
       end
@@ -39,15 +50,14 @@ module HealthCheck
 
     protected
 
-    def send_response(msg, text_status, obj_status)
-      healthy = !msg
-      msg ||= HealthCheck.success
-      obj = { :healthy => healthy, :message => msg}
+    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' }
+        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
 
@@ -59,11 +69,12 @@ module HealthCheck
     end
 
     def check_origin_ip
+      request_ipaddr = IPAddr.new(HealthCheck.accept_proxied_requests ? request.remote_ip : request.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'
+          HealthCheck.origin_ip_whitelist.any? { |addr| IPAddr.new(addr).include? request_ipaddr }
+        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
 

data/lib/health_check/health_check_routes.rb

@@ -8,7 +8,7 @@ module ActionDispatch::Routing
 
     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' }
+      match "#{HealthCheck.uri}(/:checks)(.:format)", controller: 'health_check/health_check', action: :index, via: [:get, :post], defaults: { format: 'txt' }
     end
 
   end

data/lib/health_check/middleware_health_check.rb

@@ -1,3 +1,7 @@
+# Copyright (c) 2010-2021 Ian Heggie, released under the MIT license.
+# See MIT-LICENSE for details.
+require 'ipaddr'
+
 module HealthCheck
   class MiddlewareHealthcheck
 
@@ -59,7 +63,8 @@ module HealthCheck
     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)
+      request_ipaddr = IPAddr.new(req.ip)
+      unless HealthCheck.origin_ip_whitelist.any? { |addr| IPAddr.new(addr).include? request_ipaddr }
         [ HealthCheck.http_status_for_ip_whitelist_error,
           { 'Content-Type' => 'text/plain' },
           [ 'Health check is not allowed for the requesting IP' ]

data/lib/health_check/rabbitmq_health_check.rb

@@ -0,0 +1,16 @@
+module HealthCheck
+  class RabbitMQHealthCheck
+    extend BaseHealthCheck
+    def self.check
+      unless defined?(::Bunny)
+        raise "Wrong configuration. Missing 'bunny' gem"
+      end
+      connection = Bunny.new(HealthCheck.rabbitmq_config)
+      connection.start
+      connection.close
+      ''
+    rescue Exception => e
+      create_error 'rabbitmq', e.message
+    end
+  end
+end

data/lib/health_check/redis_health_check.rb

@@ -1,15 +1,28 @@
+# frozen_string_literal: true
+
 module HealthCheck
   class RedisHealthCheck
     extend BaseHealthCheck
 
-    def self.check
-      unless defined?(::Redis)
-        raise "Wrong configuration. Missing 'redis' gem"
+    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.close if client.connected?
+      end
+
+      def client
+        @client ||= Redis.new(
+          {
+            url: HealthCheck.redis_url,
+            password: HealthCheck.redis_password
+          }.reject { |k, v| v.nil? }
+        )
       end
-      res = ::Redis.new(url: HealthCheck.redis_url).ping
-      res == 'PONG' ? '' : "Redis.ping returned #{res.inspect} instead of PONG"
-    rescue Exception => e
-      create_error 'redis', e.message
     end
   end
 end

data/lib/health_check/s3_health_check.rb

@@ -5,7 +5,7 @@ module HealthCheck
     class << self
       def check
         unless defined?(::Aws)
-          raise "Wrong configuration. Missing 'aws-sdk' gem"
+          raise "Wrong configuration. Missing 'aws-sdk' or 'aws-sdk-s3' gem"
         end
         return create_error 's3', 'Could not connect to aws' if aws_s3_client.nil?
         HealthCheck.buckets.each do |bucket_name, permissions|
@@ -27,19 +27,14 @@ module HealthCheck
 
       private
 
+      # We already assume you are using Rails.  Let's also assume you have an initializer
+      # created for your Aws config.  We will set the region here so you can use an
+      # instance profile and simply set the region in your environment.
       def configure_client
-        return unless defined?(Rails)
+        ::Aws.config[:s3] = { force_path_style: true }
+        ::Aws.config[:region] ||= ENV['AWS_REGION'] || ENV['DEFAULT_AWS_REGION']
 
-        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
+        ::Aws::S3::Client.new
       end
 
       def aws_s3_client
@@ -52,13 +47,13 @@ module HealthCheck
 
       def W(bucket)
         aws_s3_client.put_object(bucket: bucket,
-                                 key: "healthcheck_#{Rails.application.class.parent_name}",
+                                 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}")
+                                    key: "healthcheck_#{::Rails.application.class.parent_name}")
       end
     end
   end

data/lib/health_check/utils.rb

@@ -6,13 +6,13 @@ module HealthCheck
 
     @@default_smtp_settings =
         {
-            :address              => "localhost",
-            :port                 => 25,
-            :domain               => 'localhost.localdomain',
-            :user_name            => nil,
-            :password             => nil,
-            :authentication       => nil,
-            :enable_starttls_auto => true,
+            address:               "localhost",
+            port:                  25,
+            domain:                'localhost.localdomain',
+            user_name:             nil,
+            password:              nil,
+            authentication:        nil,
+            enable_starttls_auto:  true
         }
 
     cattr_accessor :default_smtp_settings
@@ -55,6 +55,8 @@ module HealthCheck
             errors << HealthCheck::RedisHealthCheck.check if defined?(::Redis)
           when 's3-if-present'
             errors << HealthCheck::S3HealthCheck.check if defined?(::Aws)
+          when 'elasticsearch-if-present'
+            errors << HealthCheck::ElasticsearchHealthCheck.check if defined?(::Elasticsearch)
           when 'resque-redis'
             errors << HealthCheck::ResqueHealthCheck.check
           when 'sidekiq-redis'
@@ -63,6 +65,10 @@ module HealthCheck
             errors << HealthCheck::RedisHealthCheck.check
           when 's3'
             errors << HealthCheck::S3HealthCheck.check
+          when 'elasticsearch'
+            errors << HealthCheck::ElasticsearchHealthCheck.check
+          when 'rabbitmq'
+            errors << HealthCheck::RabbitMQHealthCheck.check
           when "standard"
             errors << HealthCheck::Utils.process_checks(HealthCheck.standard_checks, called_from_middleware)
           when "middleware"
@@ -84,15 +90,16 @@ module HealthCheck
               return "invalid argument to health_test."
             end
         end
+        errors << '. ' unless errors == '' || errors.end_with?('. ')
       end
-      return errors
+      return errors.strip
     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')
+      @@db_migrate_path ||= File.join(::Rails.root, 'db', 'migrate')
     end
 
     def self.db_migrate_path=(value)
@@ -135,36 +142,43 @@ module HealthCheck
       status = ''
       begin
         if @skip_external_checks
-          status = '221'
+          status = '250'
         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
+          smtp = Net::SMTP.new(settings[:address], settings[:port])
+          smtp.enable_starttls if settings[:enable_starttls_auto]
+          smtp.open_timeout = timeout
+          smtp.read_timeout = timeout
+          smtp.start(settings[:domain], settings[:user_name], settings[:password], settings[:authentication]) do
+            status = smtp.helo(settings[:domain]).status
           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'}. "
+      (status =~ /^250/) ? '' : "SMTP: #{status || 'unexpected error'}. "
     end
 
     def self.check_cache
-      Rails.cache.write('__health_check_cache_test__', 'ok', :expires_in => 1.second) ? '' : 'Unable to write to cache. '
+      t = Time.now.to_i
+      value = "ok #{t}"
+      ret = ::Rails.cache.read('__health_check_cache_test__')
+      if ret.to_s =~ /^ok (\d+)$/ 
+        diff = ($1.to_i - t).abs
+        return('Cache expiry is broken. ') if diff > 30
+      elsif ret
+        return 'Cache is returning garbage. '
+      end
+      if ::Rails.cache.write('__health_check_cache_test__', value, expires_in: 2.seconds)
+        ret = ::Rails.cache.read('__health_check_cache_test__')
+        if ret =~ /^ok (\d+)$/ 
+          diff = ($1.to_i - t).abs
+          (diff < 2 ? '' : 'Out of date cache or time is skewed. ')
+        else
+          'Unable to read from cache. '
+        end
+      else
+        'Unable to write to cache. '
+      end
     end
 
   end