rx-healthcheck 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51191dafecd2e8ad24a88a3c60a44f49618f7983ded633bf58df1f482583c6a7
+  data.tar.gz: c283c8507f67d1e1d6012e8a94b33fb4ba17fd0724bde9e523388b28efa5b0ba
+SHA512:
+  metadata.gz: 7f79992064d97c64192b55378a2d5477fe11cfbfbf3aad28b92236bcaa5bcd7bb247b0df885d00c6eec17146f23620822312c39068e4dbb391d4d287a36da30f
+  data.tar.gz: 9e4cc0de75b8b3bf88e9c4588706ecd1315051f558779e53150c615e581f8b04363731b3527134a8a35044564fd08226d14c94e3c7ba3e17491dfd7acd604291

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rx.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    rx (0.1.0)
+      simplecov (= 0.21.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    docile (1.4.0)
+    minitest (5.14.4)
+    rake (13.0.3)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rx!
+
+BUNDLED WITH
+   2.2.11

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Zach Pendleton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# Rx
+
+Rx is a Rack middleware that provides tiered health checks to any Rack application, including Rails-based apps.
+
+## Tiered Health Checks
+
+What is a tiered health check? I'm glad you asked! Health checks serve different purposes:
+
+- Some are used by load balancers to ensure that a server is capable of serving traffic
+- Some are used by other applications to verify the health of your service as a dependency
+- Some are used by customers or status pages to determine uptime
+
+These use cases are all similar, but may require different levels of verification. One may require your service to just return 200, while another may need to check connectivity to the database, cache, or external services.
+
+Rx provides three levels of health checks:
+
+1. `/liveness`: A health check that determines if the server is running.
+2. `/readiness`: Readiness checks determine if critical, dependent services are running (think a database or cache)
+3. `/deep`: A health check that walks your entire dependency tree, checking other critical and secondary services.
+
+### Rails Applications
+
+Add `rx` to your Gemfile, and then create a new initializer with something like this:
+
+```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")]
+  )
+```
+
+### Configuring Dependencies
+
+Now that you're running `rx`, you will need to configure which dependencies it tests in each health check. You can do this by passing `Rx::Check` objects to the middleware. `rx` ships with a number of standard checks:
+
+- Filesystem health
+- ActiveRecord
+- HTTP
+- Generic Check
+
+In addition to the stock checks, you may create your own by copying an existing check
+and modifying it (though it's probably simpler to just use GenericCheck).
+
+`RX::Middleware` accepts the following named parameters as configuration:
+
+```ruby
+liveness: [],
+readiness: [],
+deep_critical: [],
+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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zachpendleton/rx.
+
+Some tips for developing the gem locally:
+
+* Tests can be run by calling `rake`
+* You can point your Rails app to a local gem by adding a `path` option to your Gemfile, a la `gem "rx", path: "path/to/rx" (though you _will_ need to restart Rails whenever you change the gem).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rx"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rx.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "rx/version"
+require_relative "rx/middleware"
+require_relative "rx/cache/in_memory_cache"
+require_relative "rx/cache/no_op_cache"
+require_relative "rx/check/active_record_check"
+require_relative "rx/check/file_system_check"
+require_relative "rx/check/generic_check"
+require_relative "rx/check/http_check"
+require_relative "rx/check/result"
+require_relative "rx/concurrent/future"
+require_relative "rx/concurrent/thread_pool"
+require_relative "rx/util/heap"
+
+module Rx
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/rx/cache/in_memory_cache.rb

@@ -0,0 +1,51 @@
+require_relative "../util/heap"
+
+module Rx
+  module Cache
+    class InMemoryCache
+      def initialize
+        @heap = Rx::Util::Heap.new do |a, b|
+          a[1] < b[1]
+        end
+        @lock = Mutex.new
+        @map  = Hash.new
+      end
+
+      def cache(k, expires_in = 60)
+        if value = get(k)
+          return value
+        end
+        
+        value = yield
+        put(k, value, expires_in)
+        value
+      end
+
+      def get(k)
+        clean!
+
+        lock.synchronize do
+          map[k]
+        end
+      end
+
+      def put(k, v, expires_in = 60)
+        lock.synchronize do
+          map[k] = v
+          heap << [k, Time.now + expires_in]
+        end
+      end
+
+      private
+      attr_reader :heap, :lock, :map
+
+      def clean!
+        lock.synchronize do
+          while !heap.peek.nil? && heap.peek[1] < Time.now
+            map.delete(heap.pop[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rx/cache/no_op_cache.rb

@@ -0,0 +1,17 @@
+module Rx
+  module Cache
+    class NoOpCache
+      def cache(k, expires_in = 60)
+        yield
+      end
+
+      def get(k)
+        nil
+      end
+
+      def put(k, v, expires_in = 60)
+        nil
+      end
+    end
+  end
+end

data/lib/rx/check/active_record_check.rb

@@ -0,0 +1,27 @@
+module Rx
+  module Check
+    class ActiveRecordCheck
+      attr_reader :name
+
+      def initialize(name = "activerecord")
+        @name = name
+      end
+
+      def check
+        Result.from(name) do
+          unless activerecord_defined?
+            raise StandardError.new("Undefined class ActiveRecord::Base")
+          end
+
+          ActiveRecord::Base.connection.active?
+        end
+      end
+
+      private
+
+      def activerecord_defined?
+        defined?(ActiveRecord::Base)
+      end
+    end
+  end
+end

data/lib/rx/check/file_system_check.rb

@@ -0,0 +1,22 @@
+module Rx
+  module Check
+    class FileSystemCheck
+      FILENAME = "rx".freeze
+
+      attr_reader :name
+
+      def initialize(name = "fs")
+        @name = name
+      end
+
+      def check
+        Result.from(name) do
+          !!Tempfile.open(FILENAME) do |f|
+            f.write("ok")
+            f.flush
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rx/check/generic_check.rb

@@ -0,0 +1,22 @@
+module Rx
+  module Check
+    class GenericCheck
+      attr_reader :name
+
+      def initialize(callable, name = "generic")
+        @callable = callable
+        @name = name
+      end
+
+      def check
+        Result.from(name) do
+          callable.call
+        end
+      end
+
+      private
+
+      attr_reader :callable
+    end
+  end
+end

data/lib/rx/check/http_check.rb

@@ -0,0 +1,37 @@
+require "uri"
+
+module Rx
+  module Check
+    class HttpCheck
+      attr_reader :name
+
+      def initialize(url, name = "http")
+        @url = URI(url)
+        @name = name
+      end
+
+      def check
+        Result.from(name) do
+          http = Net::HTTP.new(url.host, url.port)
+          http.read_timeout = 1
+          http.use_ssl = url.scheme == "https"
+
+          response = http.request(Net::HTTP::Get.new(path))
+          response.code == "200"
+        end
+      end
+
+      private
+
+      attr_reader :url
+
+      def path
+        path = url.path == "" ? "/" : url.path
+        path = "#{path}?#{url.query}" if url.query
+        path = "#{path}##{url.fragment}" if url.fragment
+
+        path
+      end
+    end
+  end
+end

data/lib/rx/check/result.rb

@@ -0,0 +1,34 @@
+module Rx
+  module Check
+    class Result
+      def self.from(check_name)
+        start_at = Time.now
+        err = nil
+        result = false
+
+        begin
+          result = yield
+        rescue StandardError => ex
+          err = ex
+        end
+
+        end_at = Time.now
+
+        Result.new(check_name, result, ((end_at - start_at) * 1000).round(2), err)
+      end
+
+      attr_reader :name, :timing, :error
+
+      def initialize(name, ok, timing, error)
+        @name = name
+        @ok = ok
+        @timing = timing
+        @error = error
+      end
+
+      def ok?
+        @ok
+      end
+    end
+  end
+end

data/lib/rx/concurrent/future.rb

@@ -0,0 +1,71 @@
+require "thread"
+require_relative "thread_pool"
+
+module Rx
+  module Concurrent
+    class Future
+      @@pool = ThreadPool.new.start
+
+      ALLOWED_STATES = %i[pending in_progress completed failed]
+
+      attr_reader :error
+
+      def self.execute(&block)
+        Future.new(&block).execute
+      end
+
+      def initialize(&block)
+        @channel = Queue.new
+        @state = :pending
+        @work = block
+      end
+
+      def completed?
+        state == :completed
+      end
+
+      def execute
+        @state = :in_progress
+        pool.submit do
+          begin
+            channel << work.call
+            @state = :completed
+          rescue StandardError => ex
+            @error = ex
+            @state = :failed
+            channel.close
+          end
+        end
+
+        self
+      end
+
+      def failed?
+        state == :failed
+      end
+
+      def in_progress?
+        state == :in_progress
+      end
+
+      def pending?
+        state == :pending
+      end
+
+      def value
+        if (completed? || failed?) && channel.empty?
+          return @value
+        end
+
+        @value = channel.pop
+      end
+
+      private
+      attr_reader :channel, :state, :work
+
+      def pool
+        @@pool
+      end
+    end
+  end
+end

data/lib/rx/concurrent/thread_pool.rb

@@ -0,0 +1,53 @@
+require "thread"
+
+module Rx
+  module Concurrent
+    class ThreadPool
+      def initialize(size = Etc.nprocessors)
+        @pool = []
+        @size = size
+      end
+
+      def shutdown
+        return unless started?
+
+        queue.close
+        pool.map(&:join)
+        pool.clear
+      end
+
+      def start
+        return if started?
+
+        @queue = Queue.new
+        size.times { pool << Thread.new(&worker) }
+
+        self
+      end
+
+      def started?
+        pool.map(&:alive?).any?
+      end
+
+      def submit(&block)
+        return unless started?
+        queue << block
+      end
+
+      private
+      attr_reader :pool, :queue, :size
+
+      def worker
+        -> {
+          while job = queue.pop
+            begin
+              job.call
+            rescue StandardError => _
+              # do nothing
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/lib/rx/middleware.rb

@@ -0,0 +1,95 @@
+require "json"
+
+module Rx
+  class Middleware
+    DEFAULT_OPTIONS = {
+      cache: true
+    }.freeze
+
+    def initialize(app,
+                   liveness:       [Rx::Check::FileSystemCheck.new],
+                   readiness:      [Rx::Check::FileSystemCheck.new],
+                   deep_critical:  [],
+                   deep_secondary: [],
+                   options:        {})
+      @app = app
+      @options = DEFAULT_OPTIONS.merge(options)
+      @cache = cache_factory(self.options)
+
+      @liveness_checks = liveness
+      @readiness_checks = readiness
+      @deep_critical_checks = deep_critical
+      @deep_secondary_checks = deep_secondary
+    end
+
+    def call(env)
+      unless health_check_request?(env)
+        return app.call(env)
+      end
+
+      case env["REQUEST_PATH"]
+      when "/liveness"
+        ok = check_to_component(liveness_checks).map { |x| x[:status] == 200 }.all?
+        liveness_response(ok)
+      when "/readiness"
+        readiness_response(check_to_component(readiness_checks))
+      when "/deep"
+        @cache.cache("deep") do
+          readiness = check_to_component(readiness_checks)
+          critical  = check_to_component(deep_critical_checks)
+          secondary = check_to_component(deep_secondary_checks)
+
+          deep_response(readiness, critical, secondary)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :app, :liveness_checks, :readiness_checks, :deep_critical_checks,
+                :deep_secondary_checks, :options
+
+    def cache_factory(options)
+      unless options[:cache]
+        return Rx::Cache::NoOpCache.new
+      end
+
+      Rx::Cache::InMemoryCache.new
+    end
+
+    def health_check_request?(env)
+      %w[/liveness /readiness /deep].include?(env["REQUEST_PATH"])
+    end
+
+    def liveness_response(is_ok)
+      [is_ok ? 200 : 503, {}, []]
+    end
+
+    def readiness_response(components)
+      status = components.map { |x| x[:status] == 200 }.all? ? 200 : 503
+
+      [
+        status,
+        {"content-type" => "application/json"},
+        [JSON.dump({status: status, components: components})]
+      ]
+    end
+
+    def deep_response(readiness, critical, secondary)
+      status = (readiness.map { |x| x[:status] == 200 } + critical.map { |x| x[:status] == 200 }).all? ? 200 : 503
+
+      [
+        status,
+        {"content-type" => "application/json"},
+        [JSON.dump(status: status, readiness: readiness, critical: critical, secondary: secondary)]
+      ]
+    end
+
+    def check_to_component(check)
+      Array(check)
+        .map { |check| Rx::Concurrent::Future.execute { check.check } }
+        .map(&:value)
+        .map { |r| { name: r.name, status: r.ok? ? 200 : 503, message: r.ok? ? "ok" : r.error, response_time_ms: r.timing } }
+    end
+  end
+end

data/lib/rx/util/heap.rb

@@ -0,0 +1,104 @@
+# heap = []
+# def add(value, heap)
+#   heap << value
+#   sort(heap)
+# end
+# def sort(heap)
+#   return if heap.length == 1
+#   last_parent = (heap.length - 2) / 2
+#   while last_parent >= 0
+#     l = last_parent * 2 + 1
+#     r = last_parent * 2 + 2
+#     s = last_parent
+
+#     if heap[l] < heap[last_parent]
+#       s = l
+#     end
+
+#     if r < heap.length && heap[r] < heap[last_parent]
+#       s = r
+#     end
+
+#     if s != last_parent
+#       heap[s], heap[last_parent] = heap[last_parent], heap[s]
+#     end
+
+#     last_parent -= 1
+#   end
+# end
+
+module Rx
+  module Util
+    class Heap
+      %i[empty? length size].each do |m|
+        define_method(m) { heap.send(m) }
+      end
+
+      def initialize(items = [], &comparator)
+        @heap = items.dup
+        @comparator = block_given? ? comparator : -> (a, b) { a < b }
+        sort!
+      end
+
+      def <<(item)
+        push(item)
+      end
+
+      def peek
+        heap.first
+      end
+
+      def pop
+        item = heap.shift
+        sort!
+        item
+      end
+
+      def push(item)
+        heap << item
+        sort!
+        self
+      end
+
+      private
+
+      attr_reader :comparator, :heap
+
+      def left(n)
+        2 * n + 1
+      end
+
+      def parent(n)
+        (n - 1) / 2
+      end
+
+      def right(n)
+        2 * n + 2
+      end
+
+      def sort!
+        return if heap.length <= 1
+        n = parent(heap.length - 1)
+        while n >= 0
+          l = left(n)
+          r = right(n)
+          s = n
+
+          if comparator.call(heap[l], heap[s])
+            s = l
+          end
+
+          if r < heap.length && comparator.call(heap[r], heap[s])
+            s = r
+          end
+
+          if s != n
+            heap[s], heap[n] = heap[n], heap[s]
+          end
+
+          n -= 1
+        end
+      end
+    end
+  end
+end

data/lib/rx/version.rb

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

data/rx.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/rx/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rx-healthcheck"
+  spec.version       = Rx::VERSION
+  spec.authors       = ["Zach Pendleton"]
+  spec.email         = ["zachpendleton@gmail.com"]
+
+  spec.summary       = "Standard health checks for Rails and Rack applications"
+  spec.homepage      = "https://github.com/zachpendleton/rx"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/zachpendleton/rx"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "simplecov", "0.21.2"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: rx-healthcheck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zach Pendleton
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+description: 
+email:
+- zachpendleton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rx.rb
+- lib/rx/cache/in_memory_cache.rb
+- lib/rx/cache/no_op_cache.rb
+- lib/rx/check/active_record_check.rb
+- lib/rx/check/file_system_check.rb
+- lib/rx/check/generic_check.rb
+- lib/rx/check/http_check.rb
+- lib/rx/check/result.rb
+- lib/rx/concurrent/future.rb
+- lib/rx/concurrent/thread_pool.rb
+- lib/rx/middleware.rb
+- lib/rx/util/heap.rb
+- lib/rx/version.rb
+- rx.gemspec
+homepage: https://github.com/zachpendleton/rx
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zachpendleton/rx
+  source_code_uri: https://github.com/zachpendleton/rx
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Standard health checks for Rails and Rack applications
+test_files: []