rx-healthcheck 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ca68e3e5241e5baf4b9b2454ece5f8cc87889f018ac31dfdb8e2243d58107da
-  data.tar.gz: eda14ecb4304cb18e4b95f2f0431d23b14c119c1b95e25622711cf5aa193019a
+  metadata.gz: 825528f73f53ce6f4a0da5495543859293ee6688e23cf1b1365206738e02e420
+  data.tar.gz: 2b447c79ac8bed5bf4e3ee84fc19e1eda62575368d714b5eb4ea472fcb59ed77
 SHA512:
-  metadata.gz: f59ce880cd0cba664a0705b76393bdefa84a7b91e595c001b9d59bc0161be13b32d5736ffd57db204c495f2537045cc23932c0bebb51c13b94081664111fbd7b
-  data.tar.gz: d333264758d8233c45b397cda440528a24474a2000b0ddb9950dbf87feb81444c464015e1d7aa27f241efabec21b37b231518b57fb1f3fe0fc05fc53b6c8cb12
+  metadata.gz: b10aa92da2efb24e41afc29637df1160c73e6af556be2a3db64d69949b8163c84a5a7b05c3050b52e2189231140669fdb94113554196cd7d2eaa5fa628e997f1
+  data.tar.gz: fa7b6088065d80115b39b844e7773ddd640720da0e7a69fba29a6552ae736b359d8dd32df31626fc6c3891c93cab978403b1506515feec72de2325a87c93323f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rx-healthcheck (0.1.8)
+    rx-healthcheck (0.1.10)
 
 GEM
   remote: https://rubygems.org/
@@ -17,6 +17,7 @@ GEM
     simplecov_json_formatter (0.1.3)
 
 PLATFORMS
+  ruby
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -59,6 +59,28 @@ deep_secondary: []
 
 Each collection must contain 0 or more `Rx::Check` objects. Those checks will be performed when the health check is queried. Deep checks will always also run the readiness checks.
 
+### Cache
+
+For deep health checks Rx by default will use an in-memory cache. While this is useful when running in production, during testing it could lead to unexpected results.
+You can disable the in-memory cache by setting the cache key false in the options hash.
+
+```ruby
+Rails.application.config.middleware.insert(
+  Rx::Middleware,
+    liveness: [Rx::Check::FileSystemCheck.new],
+    readiness: [
+      Rx::Check::FileSystemCheck.new,
+      Rx::Check::ActiveRecordCheck.new,
+      Rx::Check::HttpCheck.new("http://example.com"),
+      Rx::Check::GenericCheck.new(-> { $redis.ping == "PONG" }, "redis")],
+    deep_critical: [Rx::Check::HttpCheck.new("http://criticalservice.com/health")],
+    deep_secondary: [Rx::Check::HttpCheck.new("http://otherservice.com/health-check")],
+    options: {
+      cache: false
+    }
+  )
+```
+
 ### Deep end-point authorization
 
 It is considered as a good practice to protect the deep checks with a GUID to mitigate DDOS attacks. Hence you have 2 options to enable this. One is to use the `default_authorization` by passing the token to the authorization inside options hash, which you can use in a request with the authorization_token in the header of it. The other option would be to pass a lambda with an env argument (this gives you access to hash of request data) and have your own `custom_authorization`:
@@ -75,6 +97,19 @@ options: {
  }
 ```
 
+### Customizing health-check endpoints
+
+By default, Rx will mount the health checks at `/liveness`, `/readiness`, and `/deep`. You can customize these endpoints by passing a `liveness_path`, `readiness_path`, and `deep_path` options to the middleware:
+
+```ruby
+# in this example, liveness and readiness endpoints have been customized. the deep
+# endpoint will use the default path (/deep).
+Rx::Middleware.new(options: {
+  liveness_path: "/other_liveness",
+  readiness_path: "/other_readiness"
+})
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/zachpendleton/rx.

data/lib/rx/cache/{in_memory_cache.rb → lru_cache.rb}

@@ -2,7 +2,7 @@ require_relative "../util/heap"
 
 module Rx
   module Cache
-    class InMemoryCache
+    class LRUCache
       def initialize
         @heap = Rx::Util::Heap.new do |a, b|
           a[1] < b[1]

data/lib/rx/cache/map_cache.rb

@@ -0,0 +1,45 @@
+require "thread"
+
+module Rx
+  module Cache
+    class MapCache
+      def initialize
+        @data = {}
+        @lock = Mutex.new
+      end
+
+      def cache(k, expires_in = 60)
+        unless (value = get(k)).nil?
+          return value
+        end
+
+        value = yield
+        put(k, value, expires_in)
+        value
+      end
+
+      def get(k)
+        lock.synchronize do
+          value = data[k]
+          return nil unless value
+
+          if value[1] < Time.now
+            data.delete(k)
+            return nil
+          end
+          
+          value[0]
+        end
+      end
+
+      def put(k, v, expires_in = 60)
+        lock.synchronize do
+          data[k] = [v, Time.now + expires_in]
+        end
+      end
+
+      private
+      attr_reader :data, :lock
+    end
+  end
+end

data/lib/rx/middleware.rb

@@ -4,7 +4,10 @@ module Rx
   class Middleware
     DEFAULT_OPTIONS = {
       cache: true,
-      authorization: nil
+      authorization: nil,
+      liveness_path: "/liveness",
+      readiness_path: "/readiness",
+      deep_path: "/deep"
     }.freeze
 
     def initialize(app,
@@ -29,12 +32,12 @@ module Rx
       end
 
       case path(env)
-      when "/liveness"
+      when @options[:liveness_path]
         ok = check_to_component(liveness_checks).map { |x| x[:status] == 200 }.all?
         liveness_response(ok)
-      when "/readiness"
+      when @options[:readiness_path]
         readiness_response(check_to_component(readiness_checks))
-      when "/deep"
+      when @options[:deep_path]
         if !Rx::Util::HealthCheckAuthorization.new(env, @options[:authorization]).ok?
           deep_response_authorization_failed
         else
@@ -55,15 +58,20 @@ module Rx
                 :deep_secondary_checks, :options
 
     def cache_factory(options)
-      unless options[:cache]
-        return Rx::Cache::NoOpCache.new
+      case options[:cache]
+      when true
+        Rx::Cache::LRUCache.new
+      when "LRU"
+        Rx::Cache::LRUCache.new
+      when "MAP"
+        Rx::Cache::MapCache.new
+      else
+        Rx::Cache::NoOpCache.new
       end
-
-      Rx::Cache::InMemoryCache.new
     end
 
     def health_check_request?(path)
-      %w[/liveness /readiness /deep].include?(path)
+      [@options[:liveness_path], @options[:readiness_path], @options[:deep_path]].include?(path)
     end
 
     def liveness_response(is_ok)

data/lib/rx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rx
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

data/lib/rx.rb

@@ -2,7 +2,8 @@
 
 require_relative "rx/version"
 require_relative "rx/middleware"
-require_relative "rx/cache/in_memory_cache"
+require_relative "rx/cache/lru_cache"
+require_relative "rx/cache/map_cache"
 require_relative "rx/cache/no_op_cache"
 require_relative "rx/check/active_record_check"
 require_relative "rx/check/file_system_check"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rx-healthcheck
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Zach Pendleton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-31 00:00:00.000000000 Z
+date: 2022-11-09 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -26,7 +26,8 @@ files:
 - bin/console
 - bin/setup
 - lib/rx.rb
-- lib/rx/cache/in_memory_cache.rb
+- lib/rx/cache/lru_cache.rb
+- lib/rx/cache/map_cache.rb
 - lib/rx/cache/no_op_cache.rb
 - lib/rx/check/active_record_check.rb
 - lib/rx/check/file_system_check.rb
@@ -61,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Standard health checks for Rails and Rack applications