rails_health_checks 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 128aa6485e85de5719cfb25c05192f5dd0277f8277bc6c8b4f74a095402f5f4b
-  data.tar.gz: e3b5eb28dd364012552e7f91e3e3b01f9d1db3778b4f7d0fe88662aed45c4073
+  metadata.gz: d0f595984abf8a7db84183766d61918bdf684642b6ea67b2075afbda8f4cbae6
+  data.tar.gz: ab35a0deb32d298eae8dadc04c39dbf8ca34b8e77018625ebad8ba81e1901f34
 SHA512:
-  metadata.gz: 02001fd4bbb80bc41567c449c4653aef0afa72766b1413cabe9cbbe61a248d2ef6c86bc1ae18bd2fad378b46748b9550e0b74001026514233de55aa04cc4f6ea
-  data.tar.gz: 34460c74d90057174f63461569e2132e320ec4440141e7914fa9c82075b6268f46680514f667dfe9a8eb6932964ab30ffa1d80f071bf8f22e15f9e8a5f6aaa0b
+  metadata.gz: 2f2db831794c15dbf59c6763ed65a092e9bc56db1dc87e35d4565cccd63303cfe9555a7b36f738e6a861086c0362f8eb98459e99ea46f5838bfeb3862130ebf5
+  data.tar.gz: 3d5b057c32506961cf0416d37ea45c70f5218767961ddeed208b37887abd7781187fc1f480aff2e5fb522bfad8400e355fa745a04ec876a064e1aeb938e91c78

data/README.md

@@ -76,7 +76,7 @@ Status values: `ok` | `degraded` | `critical`. Overall status is `critical` if a
 ```ruby
 # config/initializers/rails_health_checks.rb
 RailsHealthChecks.configure do |config|
-  config.checks  = [:database]  # checks to run (default: [:database])
+  config.checks  = [:database, :cache]  # checks to run (default: [:database])
   config.timeout = 5            # global timeout per check in seconds (default: 5)
 end
 ```
@@ -126,6 +126,14 @@ The block receives the `ActionDispatch::Request` object and must return a truthy
 | Check | Description |
 |-------|-------------|
 | `:database` | ActiveRecord `SELECT 1` against the primary connection, includes latency |
+| `:cache` | `Rails.cache` read/write probe; works with Redis, Memcached, or in-process store |
+| `:sidekiq` | Sidekiq Redis connectivity; optional `config.sidekiq_queue_size` threshold for queue depth |
+| `:solid_queue` | Solid Queue DB connectivity; optional `config.solid_queue_job_count` threshold for pending jobs |
+| `:good_job` | GoodJob queue latency; optional `config.good_job_latency` (seconds) threshold for oldest pending job |
+| `:resque` | Resque Redis connectivity; optional `config.resque_queue_size` threshold for total queue depth |
+| `:disk` | Free disk bytes via `df`; optional `config.disk_warn_threshold` / `config.disk_critical_threshold` (bytes) and `config.disk_path` (default: `/`) |
+| `:memory` | Process RSS via `ps`; optional `config.memory_threshold` (bytes) reports `degraded` when exceeded |
+| `:http` | HTTP GET to `config.http_url`; reports `critical` if response code differs from `config.http_expected_status` (default: `200`) or a network error occurs |
 
 [↑ Back to top](#table-of-contents)
 

data/lib/rails_health_checks/check_registry.rb

@@ -5,7 +5,22 @@ require "timeout"
 module RailsHealthChecks
   class CheckRegistry
     BUILT_INS = {
-      database: -> { Checks::DatabaseCheck.new }
+      database: -> { Checks::DatabaseCheck.new },
+      cache:    -> { Checks::CacheCheck.new },
+      sidekiq:     -> { Checks::SidekiqCheck.new(queue_size: RailsHealthChecks.configuration.sidekiq_queue_size) },
+      solid_queue: -> { Checks::SolidQueueCheck.new(job_count: RailsHealthChecks.configuration.solid_queue_job_count) },
+      good_job:    -> { Checks::GoodJobCheck.new(latency: RailsHealthChecks.configuration.good_job_latency) },
+      resque:      -> { Checks::ResqueCheck.new(queue_size: RailsHealthChecks.configuration.resque_queue_size) },
+      memory:      -> { Checks::MemoryCheck.new(threshold: RailsHealthChecks.configuration.memory_threshold) },
+      http:        -> { Checks::HttpCheck.new(
+        url:             RailsHealthChecks.configuration.http_url,
+        expected_status: RailsHealthChecks.configuration.http_expected_status
+      ) },
+      disk:        -> { Checks::DiskCheck.new(
+        warn_threshold:     RailsHealthChecks.configuration.disk_warn_threshold,
+        critical_threshold: RailsHealthChecks.configuration.disk_critical_threshold,
+        path:               RailsHealthChecks.configuration.disk_path
+      ) }
     }.freeze
 
     def self.build(check_names)

data/lib/rails_health_checks/checks/cache_check.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsHealthChecks
+  module Checks
+    class CacheCheck < Check
+      PROBE_KEY = "rails_health_checks:cache_probe"
+      PROBE_VALUE = "ok"
+
+      def call
+        measure do
+          Rails.cache.write(PROBE_KEY, PROBE_VALUE, expires_in: 10)
+          result = Rails.cache.read(PROBE_KEY)
+          raise "unexpected value: #{result.inspect}" unless result == PROBE_VALUE
+        end
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/disk_check.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RailsHealthChecks
+  module Checks
+    class DiskCheck < Check
+      def initialize(warn_threshold: nil, critical_threshold: nil, path: "/")
+        @warn_threshold = warn_threshold
+        @critical_threshold = critical_threshold
+        @path = path
+      end
+
+      def call
+        free = nil
+        measure { free = free_bytes }
+
+        if @critical_threshold && free < @critical_threshold
+          return fail_with("free disk space #{free} bytes below critical threshold #{@critical_threshold} bytes")
+        end
+
+        if @warn_threshold && free < @warn_threshold
+          return warn_with("free disk space #{free} bytes below warn threshold #{@warn_threshold} bytes")
+        end
+
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+
+      private
+
+      def free_bytes
+        out, _, status = Open3.capture3("df", "-Pk", @path.to_s)
+        raise "df command failed with exit status #{status.exitstatus}" unless status.success?
+
+        parts = out.split("\n").last.split
+        parts[3].to_i * 1024
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/good_job_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RailsHealthChecks
+  module Checks
+    class GoodJobCheck < Check
+      def initialize(latency: nil)
+        unless defined?(::GoodJob)
+          raise LoadError, "GoodJob is not installed. Add `gem 'good_job'` to your Gemfile to use the :good_job check."
+        end
+
+        @latency = latency
+      end
+
+      def call
+        measure do
+          oldest = ::GoodJob::Job
+            .where(finished_at: nil, performed_at: nil)
+            .minimum(:created_at)
+
+          if @latency && oldest
+            age = (Time.current - oldest).to_i
+            return warn_with("queue latency #{age}s exceeds threshold #{@latency}s") if age > @latency
+          end
+        end
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/http_check.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module RailsHealthChecks
+  module Checks
+    class HttpCheck < Check
+      def initialize(url:, expected_status: 200)
+        @url = url
+        @expected_status = expected_status
+      end
+
+      def call
+        measure do
+          response = Net::HTTP.get_response(URI.parse(@url))
+          code = response.code.to_i
+          return fail_with("HTTP GET #{@url} returned #{code}, expected #{@expected_status}") if code != @expected_status
+        end
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/memory_check.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RailsHealthChecks
+  module Checks
+    class MemoryCheck < Check
+      def initialize(threshold: nil)
+        @threshold = threshold
+      end
+
+      def call
+        rss = nil
+        measure { rss = rss_bytes }
+
+        if @threshold && rss > @threshold
+          return warn_with("process RSS #{rss} bytes exceeds threshold #{@threshold} bytes")
+        end
+
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+
+      private
+
+      def rss_bytes
+        out, _, status = Open3.capture3("ps", "-o", "rss=", "-p", Process.pid.to_s)
+        raise "ps command failed with exit status #{status.exitstatus}" unless status.success?
+
+        out.strip.to_i * 1024
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/resque_check.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsHealthChecks
+  module Checks
+    class ResqueCheck < Check
+      def initialize(queue_size: nil)
+        unless defined?(::Resque)
+          raise LoadError, "Resque is not installed. Add `gem 'resque'` to your Gemfile to use the :resque check."
+        end
+
+        @queue_size = queue_size
+      end
+
+      def call
+        measure { ::Resque.redis.ping }
+
+        if @queue_size
+          depth = ::Resque.queues.sum { |q| ::Resque.size(q) }
+          return warn_with("queue depth #{depth} exceeds threshold #{@queue_size}") if depth > @queue_size
+        end
+
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/sidekiq_check.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsHealthChecks
+  module Checks
+    class SidekiqCheck < Check
+      def initialize(queue_size: nil)
+        unless defined?(::Sidekiq)
+          raise LoadError, "Sidekiq is not installed. Add `gem 'sidekiq'` to your Gemfile to use the :sidekiq check."
+        end
+
+        @queue_size = queue_size
+      end
+
+      def call
+        measure { ::Sidekiq.redis { |conn| conn.ping } }
+
+        if @queue_size
+          depth = ::Sidekiq::Queue.all.sum(&:size)
+          return warn_with("queue depth #{depth} exceeds threshold #{@queue_size}") if depth > @queue_size
+        end
+
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/checks/solid_queue_check.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RailsHealthChecks
+  module Checks
+    class SolidQueueCheck < Check
+      def initialize(job_count: nil)
+        unless defined?(::SolidQueue)
+          raise LoadError, "SolidQueue is not installed. Add `gem 'solid_queue'` to your Gemfile to use the :solid_queue check."
+        end
+
+        @job_count = job_count
+      end
+
+      def call
+        measure do
+          pending = ::SolidQueue::ReadyExecution.count
+          if @job_count && pending > @job_count
+            return warn_with("pending job count #{pending} exceeds threshold #{@job_count}")
+          end
+        end
+        pass
+      rescue StandardError => e
+        fail_with(e.message)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/configuration.rb

@@ -2,7 +2,9 @@
 
 module RailsHealthChecks
   class Configuration
-    attr_accessor :checks, :timeout, :allowed_ips, :token
+    attr_accessor :checks, :timeout, :allowed_ips, :token, :sidekiq_queue_size, :solid_queue_job_count, :good_job_latency,
+                  :resque_queue_size, :disk_warn_threshold, :disk_critical_threshold, :disk_path,
+                  :memory_threshold, :http_url, :http_expected_status
     attr_reader :authenticate_block
 
     def initialize
@@ -11,6 +13,16 @@ module RailsHealthChecks
       @allowed_ips = nil
       @token = nil
       @authenticate_block = nil
+      @sidekiq_queue_size = nil
+      @solid_queue_job_count = nil
+      @good_job_latency = nil
+      @resque_queue_size = nil
+      @disk_warn_threshold = nil
+      @disk_critical_threshold = nil
+      @disk_path = "/"
+      @memory_threshold = nil
+      @http_url = nil
+      @http_expected_status = 200
     end
 
     def authenticate(&block)

data/lib/rails_health_checks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsHealthChecks
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/rails_health_checks.rb

@@ -6,6 +6,14 @@ require "rails_health_checks/configuration"
 require "rails_health_checks/authentication"
 require "rails_health_checks/check"
 require "rails_health_checks/checks/database_check"
+require "rails_health_checks/checks/cache_check"
+require "rails_health_checks/checks/sidekiq_check"
+require "rails_health_checks/checks/solid_queue_check"
+require "rails_health_checks/checks/good_job_check"
+require "rails_health_checks/checks/resque_check"
+require "rails_health_checks/checks/disk_check"
+require "rails_health_checks/checks/memory_check"
+require "rails_health_checks/checks/http_check"
 require "rails_health_checks/check_registry"
 require "rails_health_checks/response_builder"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_health_checks
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Chuck Smith
@@ -44,7 +44,15 @@ files:
 - lib/rails_health_checks/authentication.rb
 - lib/rails_health_checks/check.rb
 - lib/rails_health_checks/check_registry.rb
+- lib/rails_health_checks/checks/cache_check.rb
 - lib/rails_health_checks/checks/database_check.rb
+- lib/rails_health_checks/checks/disk_check.rb
+- lib/rails_health_checks/checks/good_job_check.rb
+- lib/rails_health_checks/checks/http_check.rb
+- lib/rails_health_checks/checks/memory_check.rb
+- lib/rails_health_checks/checks/resque_check.rb
+- lib/rails_health_checks/checks/sidekiq_check.rb
+- lib/rails_health_checks/checks/solid_queue_check.rb
 - lib/rails_health_checks/configuration.rb
 - lib/rails_health_checks/engine.rb
 - lib/rails_health_checks/response_builder.rb