rack-ecg 0.0.3 → 0.2.0

data/lib/rack/ecg/check/active_record_connection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rack
+  class ECG
+    module Check
+      # @!method initialize
+      #   Checks whether ActiveRecord is currently connected to the default
+      #   database.
+      class ActiveRecordConnection
+        def result
+          value = ""
+          status = Status::OK
+          begin
+            if defined?(ActiveRecord)
+              value = ::ActiveRecord::Base.connection.active?
+              status = value ? Status::OK : Status::ERROR
+            else
+              status = Status::ERROR
+              value = "ActiveRecord not found"
+            end
+          rescue => e
+            status = Status::ERROR
+            value = e.message
+          end
+
+          Result.new(:active_record, status, value.to_s)
+        end
+
+        CheckRegistry.instance.register(:active_record, ActiveRecordConnection)
+      end
+    end
+  end
+end

data/lib/rack/ecg/check/error.rb

@@ -1,16 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "./static"
+
 module Rack
   class ECG
     module Check
-      # if rack-ecg is serving a request - http is obviously working so far...
-      # this is basically a "hello-world"
-      class Error
-        def result
-          Result.new(:error, "error", "PC LOAD LETTER")
+      # @!method initialize
+      #   Always returns a basic error for testing purposes.
+      class Error < Static
+        STATIC_PARAMETERS = {
+          name: :error,
+          success: false,
+          value: "PC LOAD LETTER",
+        }.freeze
+
+        def initialize
+          super(STATIC_PARAMETERS)
         end
       end
 
       CheckRegistry.instance.register(:error, Error)
-
     end
   end
 end

data/lib/rack/ecg/check/git_revision.rb

@@ -1,13 +1,22 @@
+# frozen_string_literal: true
+
 module Rack
   class ECG
     module Check
+      # @deprecated This check requires the presence of the git executable, and executes it every time to determine the
+      #   current revision. Consider checking the revision at initialization time, and returning it via a {Static} check
+      #   instead.
+      #
+      # @!method initialize
+      #   Returns the SHA1 of the current commit, as reported by the git
+      #   executable.
       class GitRevision
         def result
           _stdin, stdout, stderr, wait_thread = Open3.popen3("git rev-parse HEAD")
 
           success = wait_thread.value.success?
 
-          status = success ? "ok" : "error"
+          status = success ? Status::OK : Status::ERROR
 
           value = success ? stdout.read : stderr.read
           value = value.strip
@@ -17,7 +26,6 @@ module Rack
       end
 
       CheckRegistry.instance.register(:git_revision, GitRevision)
-
     end
   end
 end

data/lib/rack/ecg/check/http.rb

@@ -1,16 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "./static"
+
 module Rack
   class ECG
     module Check
-      # if rack-ecg is serving a request - http is obviously working so far...
-      # this is basically a "hello-world"
-      class Http
-        def result
-          Result.new(:http, "ok", "online")
+      # @!method initialize
+      #   Always returns a success.
+      class Http < Static
+        STATIC_PARAMETERS = {
+          name: :http,
+          success: true,
+          value: "online",
+        }.freeze
+
+        def initialize
+          super(STATIC_PARAMETERS)
         end
       end
 
       CheckRegistry.instance.register(:http, Http)
-
     end
   end
 end

data/lib/rack/ecg/check/migration_version.rb

@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
 module Rack
   class ECG
     module Check
+      # @!method initialize
+      #   Returns the latest applied ActiveRecord migration in the default
+      #   database.
       class MigrationVersion
         def result
           value = ""
-          status = "ok"
+          status = Status::OK
           begin
             if defined?(ActiveRecord)
               connection = ActiveRecord::Base.connection
               value = connection.select_value("select max(version) from schema_migrations")
             else
-              status = "error"
+              status = Status::ERROR
               value = "ActiveRecord not found"
             end
           rescue => e
-            status = "error"
+            status = Status::ERROR
             value = e.message
           end
 
@@ -23,7 +28,6 @@ module Rack
       end
 
       CheckRegistry.instance.register(:migration_version, MigrationVersion)
-
     end
   end
 end

data/lib/rack/ecg/check/redis_connection.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rack
+  class ECG
+    module Check
+      # @!method initialize
+      #   Checks whether the given Redis client is currently connected to the
+      #   database as identified by the ++instance++ option.
+      #
+      # @option parameters instance [Redis] The Redis client
+      class RedisConnection
+        attr_reader :redis_instance
+
+        def initialize(parameters = {})
+          @redis_instance = parameters[:instance]
+        end
+
+        def result
+          value = ""
+          status = Status::OK
+          begin
+            if redis_instance.nil?
+              status = Status::ERROR
+              value = "Redis instance parameters not found"
+            elsif defined?(::Redis)
+              value = redis_instance.connected?
+              status = value ? Status::OK : Status::ERROR
+            else
+              status = Status::ERROR
+              value = "Redis not found"
+            end
+          rescue => e
+            status = Status::ERROR
+            value = e.message
+          end
+
+          Result.new(:redis, status, value.to_s)
+        end
+
+        CheckRegistry.instance.register(:redis, RedisConnection)
+      end
+    end
+  end
+end

data/lib/rack/ecg/check/sequel_connection.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rack
+  class ECG
+    module Check
+      class SequelConnection
+        attr_reader :connection_parameters, :name
+
+        # Checks whether Sequel can connect to the database identified by the
+        # ++connection++ option.
+        #
+        # @option parameters connection [String,Hash] Sequel connection parameters to check
+        # @option parameters name [String,nil] Name to distinguish multiple Sequel checks
+        def initialize(parameters = {})
+          @connection_parameters = parameters[:connection]
+          @name = parameters[:name]
+        end
+
+        def result
+          value = ""
+          status = Status::OK
+          begin
+            if connection_parameters.nil?
+              status = Status::ERROR
+              value = "Sequel Connection parameters not found"
+            elsif defined?(::Sequel)
+              ::Sequel.connect(connection_parameters) do |db|
+                value = db.test_connection
+                status = Status::OK
+              end
+            else
+              status = Status::ERROR
+              value = "Sequel not found"
+            end
+          rescue => e
+            status = Status::ERROR
+            value = e.message
+          end
+
+          Result.new(result_key.to_sym, status, value.to_s)
+        end
+
+        def result_key
+          if name
+            "sequel #{name.downcase}".gsub(/\W+/, "_")
+          else
+            "sequel"
+          end
+        end
+
+        CheckRegistry.instance.register(:sequel, SequelConnection)
+      end
+    end
+  end
+end

data/lib/rack/ecg/check/static.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rack
+  class ECG
+    module Check
+      class Static
+        # Always returns the provided ++value++ under the ++name++ key, with the result set by ++status++.
+        #
+        # @example Return "Hello, world!" under ++static++
+        #   use(Rack::ECG, { checks: [[:static, { value: "Hello, world!" }]] })
+        #
+        # @example Return "Paper jam in tray 2" as an error under ++printer_status++
+        #   use(Rack::ECG, {
+        #     checks: [
+        #       [
+        #         :static,
+        #         {
+        #           value: "Paper jam in tray 2",
+        #           success: false, # or status: Rack::ECG::Check::Status::ERROR
+        #           name: :printer_status,
+        #         },
+        #       ],
+        #     ],
+        #   })
+        #
+        # @option parameters value [Object] (nil) Result value
+        # @option parameters status [Status::ERROR, Status::OK, nil] (nil) Result status (takes precedence over
+        #   ++success++)
+        # @option parameters success [Boolean] (true) Whether the result is successful
+        # @option parameters name [Symbol, #to_sym] (:static) Key for the check result in the response
+        def initialize(parameters)
+          parameters ||= {}
+
+          @name = parameters.fetch(:name, :static).to_sym
+          @value = parameters.fetch(:value, nil)
+
+          @status = if parameters.key?(:status)
+            parameters[:status]
+          else
+            parameters.fetch(:success, true) ? Status::OK : Status::ERROR
+          end
+        end
+
+        def result
+          Result.new(@name, @status, @value)
+        end
+      end
+
+      CheckRegistry.instance.register(:static, Static)
+    end
+  end
+end

data/lib/rack/ecg/check.rb

@@ -1,15 +1,45 @@
+# frozen_string_literal: true
+
 require "rack/ecg/check_registry"
+require "rack/ecg/check/active_record_connection"
 require "rack/ecg/check/error"
 require "rack/ecg/check/git_revision"
 require "rack/ecg/check/http"
 require "rack/ecg/check/migration_version"
+require "rack/ecg/check/redis_connection"
+require "rack/ecg/check/sequel_connection"
+require "rack/ecg/check/static"
 
 module Rack
   class ECG
     module Check
+      # Possible recognised check statuses.
+      module Status
+        # Indicates the check was successful.
+        OK = "ok"
+        # Indicates the check errored.
+        ERROR = "error"
+      end
+
       class Result < Struct.new(:name, :status, :value)
+        # Format the result as a JSON compatible hash.
+        #
+        # @return [Hash<Object, Hash<Symbol, Object>>] Result in a hash format.
+        # @example A HTTP success response
+        #   puts result.as_json
+        #   # {:http=>{:status=>"ok", :value=>"online"}}
+        def as_json
+          { name => { status: status, value: value } }
+        end
+
+        # Return the result as a JSON object.
+        #
+        # @return [String] Result in a JSON object string.
+        # @example A HTTP success response
+        #   puts result.to_json
+        #   # {"http": {"status": "ok", "value": "online"}}
         def to_json
-          {name => {:status => status, :value => value}}
+          JSON.dump(as_json)
         end
       end
     end

data/lib/rack/ecg/check_factory.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rack/ecg/check"
+
+module Rack
+  class ECG
+    class CheckFactory
+      CheckDefinition = Struct.new(:check_class, :parameters)
+
+      def initialize(definitions, default_checks = [])
+        definitions = Array(definitions) | default_checks
+
+        @checks = definitions.map do |check_name, check_parameters|
+          CheckDefinition.new(CheckRegistry.lookup(check_name), check_parameters)
+        end
+      end
+
+      def build_all
+        @checks.map do |check_definition|
+          build(check_definition.check_class, check_definition.parameters)
+        end
+      end
+
+      def build(check_class, parameters = nil)
+        parameters.nil? ? check_class.new : check_class.new(parameters)
+      end
+    end
+  end
+end

data/lib/rack/ecg/check_registry.rb

@@ -1,20 +1,43 @@
+# frozen_string_literal: true
+
 require "singleton"
 
 module Rack
   class ECG
     class CheckRegistry
+      # Raised when a check didn't exist during lookup
+      CheckNotRegistered = Class.new(StandardError)
       include Singleton
 
-      def initialize()
+      # Constructs the singleton instance of the registry
+      def initialize
         @registry = {}
       end
 
+      # Register a check class by name
+      #
+      # @param [Symbol] name Desired check name
+      # @param [Class] check_class Class implementing check functionality
       def register(name, check_class)
         @registry[name] = check_class
       end
 
-      def [](name)
-        @registry[name]
+      # Fetches the registered check class by name
+      #
+      # @param [Symbol] name Registered check name
+      # @raise [CheckNotRegistered] if the named check has not been registered
+      def lookup(name)
+        @registry.fetch(name) { raise CheckNotRegistered, "Check '#{name}' is not registered" }
+      end
+
+      # (see #lookup)
+      def self.lookup(name)
+        instance.lookup(name)
+      end
+
+      # (see #register)
+      def self.register(name, check_class)
+        instance.register(name, check_class)
       end
     end
   end

data/lib/rack/ecg/version.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Rack
   class ECG
-    VERSION = "0.0.3"
+    # Library version.
+    VERSION = "0.2.0"
   end
 end

data/lib/rack/ecg.rb

@@ -1,41 +1,53 @@
+# frozen_string_literal: true
+
 require "rack/ecg/version"
 require "json"
 require "open3"
-require "rack/ecg/check"
+require "rack/ecg/check_factory"
 
 module Rack
   class ECG
+    # Default mount path.
     DEFAULT_MOUNT_AT = "/_ecg"
-    DEFAULT_CHECKS = [ :http ]
-
-    def initialize(app=nil, options={})
+    # Checks enabled by default.
+    DEFAULT_CHECKS = [:http]
+
+    # Constructs an instance of ECG Rack middleware with the specified
+    # options.
+    #
+    # @param app [Object,nil] Underlying Rack application to receive unmatched
+    #   requests. If unset, any unmatched requests will return a 404.
+    # @param checks [Array<Symbol, Array<Symbol, Object>>] Sets and
+    #   configures the checks run by this instance.
+    # @param at [String, nil] Path which this ECG instance handles.
+    # @param hook [#call, nil] Callable which receives the success status and
+    #   check results
+    def initialize(app = nil, checks: DEFAULT_CHECKS, at: DEFAULT_MOUNT_AT, hook: nil)
       @app = app
 
-      check_names = options.delete(:checks) || []
-      @check_classes = build_check_classes(check_names)
+      check_configuration = checks || []
+      @check_factory = CheckFactory.new(check_configuration, DEFAULT_CHECKS)
+      @mount_at = at || DEFAULT_MOUNT_AT
 
-      @at = options.delete(:at) || DEFAULT_MOUNT_AT
-
-      @hook = options.delete(:hook)
+      @result_hook = hook
     end
 
+    # Rack compatible call method. Not intended for direct usage.
     def call(env)
-      if env["PATH_INFO"] == @at
+      if env["PATH_INFO"] == @mount_at
+        check_results = @check_factory.build_all.inject({}) do |results, check|
+          results.merge(check.result.as_json)
+        end
 
-        check_results = @check_classes.inject({}){|results, check_class|
-          check = check_class.new
-          results.merge(check.result.to_json)
-        }
-
-        success = check_results.none? { |check| check[1][:status] == "error" } 
+        success = check_results.none? { |check| check[1][:status] == Check::Status::ERROR }
 
         response_status = success ? 200 : 500
 
-        @hook.call(success, check_results) if @hook
+        @result_hook&.call(success, check_results)
 
         response_headers = {
-          "X-Rack-ECG-Version"  => Rack::ECG::VERSION,
-          "Content-Type"        => "application/json"
+          "X-Rack-ECG-Version" => Rack::ECG::VERSION,
+          "Content-Type" => "application/json",
         }
 
         response_body = JSON.pretty_generate(check_results)
@@ -44,19 +56,8 @@ module Rack
       elsif @app
         @app.call(env)
       else
-        [404, {},[]]
+        [404, {}, []]
       end
     end
-
-    private
-    def build_check_classes(check_names)
-      check_names = Array(check_names) # handle nil, or not a list
-      check_names = check_names | DEFAULT_CHECKS # add the :http check if it's not there
-      check_names.map{|check_name|
-        check_class = CheckRegistry.instance[check_name]
-        raise "Don't know about check #{check_name}" unless check_class
-        check_class
-      }
-    end
   end
 end

data/lib/rack-ecg.rb

@@ -1 +1,3 @@
-require 'rack/ecg'
+# frozen_string_literal: true
+
+require "rack/ecg"

data/rack-ecg.gemspec

@@ -1,28 +1,47 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rack/ecg/version'
+# frozen_string_literal: true
+
+require_relative "lib/rack/ecg/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "rack-ecg"
   spec.version       = Rack::ECG::VERSION
   spec.authors       = ["Envato", "Julian Doherty"]
   spec.email         = ["julian@envato.com"]
-  spec.summary       = %q{Rack middleware serving a health check page}
-  spec.description   = %q{rack-ecg allows you to serve a page that shows you facts about your deployed app to allow you to check that everything is running as it should: git revision, database migrations, and more}
+  spec.summary       = "Rack middleware serving a health check page"
+  spec.description   = <<-EOF
+    rack-ecg allows you to serve a page that shows you facts about your deployed
+    app to allow you to check that everything is running as it should: git
+    revision, database migrations, and more
+  EOF
   spec.homepage      = "https://github.com/envato/rack-ecg"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/envato/rack-ecg/blob/main/CHANGELOG.md"
+
+  # 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
+    %x(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_runtime_dependency "rack"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  spec.add_runtime_dependency("rack")
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.2.0"
-  spec.add_development_dependency "rack-test", "~> 0.6.3"
-  spec.add_development_dependency "pry", "~> 0.10.1"
+  spec.add_development_dependency("bundler", "~> 2.3.7")
+  spec.add_development_dependency("pry", "~> 0.14.1")
+  spec.add_development_dependency("rack-test", "~> 1.1.0")
+  spec.add_development_dependency("rake", "~> 13.0")
+  spec.add_development_dependency("redcarpet", "~> 3.5.0")
+  spec.add_development_dependency("rspec", "~> 3.11.0")
+  spec.add_development_dependency("rubocop-rake", "> 0")
+  spec.add_development_dependency("rubocop-rspec", "> 0")
+  spec.add_development_dependency("rubocop-shopify", "~> 2.4.0")
+  spec.add_development_dependency("yard", "~> 0.9.24")
 end