health_check_toolbox 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '08e0d29ece6bf2d0b6f18612857048f37d193a1a1248550cb80ef0bfe246e20d'
+  data.tar.gz: 8994b78e5e9bab353aaab7abcdef79062d769fe5efebc3cb165e9a5bca91ad4e
+SHA512:
+  metadata.gz: 850010882c01d96ae0953b2c27950ceb232eb90080c4c84441e0d7e70d14219e6dbd77875a7c7858daf83a4c5d26a76bea0818ee498d75d9cbb071ce97ea4938
+  data.tar.gz: b86ae94c8f772b531a43279db58f24f18af934a0b4ffcaa1ff36f88adbea1f60a5ae9c0518a2451e7a65f2b6b82feb08163e2cd958d3f704a058b6721a6132bc

data/README.md

@@ -0,0 +1,84 @@
+# HealthCheckToolbox
+
+A HealthCheckToolbox é uma gem para verificar o status e versão dos serviços da guide.
+
+## Installation
+Adicione essa linha em seu gem file:
+
+```ruby
+gem 'health_check_toolbox'
+```
+
+Execute:
+```bash
+$ bundle
+```
+
+Ou instale você mesmo.
+
+```bash
+$ gem install health_check_toolbox
+```
+
+## Configuração
+Adicione no `config/initializers/` o file `health_check.rb` para configurar os serviços para verificação.
+
+```ruby
+HealthCheckToolbox.setup do
+end
+```
+
+Ex.: configuração do projeto: `fund_data_service`
+```ruby
+HealthCheckToolbox.setup do
+  redis_service true
+  database true
+  wso2 true
+  rest_services do
+    file_storage_service ENV['file_storage']
+    asset_classification_service ENV['asset_classification']
+    tema_service ENV['tema_ws']
+  end
+end
+```
+
+Configurações permitidas:
+
+```ruby
+redis_service
+```
+```ruby
+database
+```
+```ruby
+wso2
+```
+```ruby
+rest_services # validação de serviços externos ( é necessário passar "_service" nas opções )
+```
+
+## Como Usar
+
+No arquivo `routes.rb` basta adicionar o seguinte código
+
+```ruby
+health_check_routes
+```
+
+Para verificar se as rotas foram incluídas no projeto rodar `rake routes`
+
+A gem possui duas rotas:
+
+```ruby
+/service_status
+```
+Verifica a versão do projeto e o status do serviço.
+
+```ruby
+/health_check
+```
+Verifica o status de todos os serviços ligados ao projeto.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  time:
+    formats:
+      timestamp: '%Y-%m-%d %H:%M:%S %z'
+      timestamp_without_zone: '%Y-%m-%d %H:%M:%S'
+      short: '%Y-%m-%d'

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  health_check_routes
+end

data/lib/health_check_toolbox.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'health_check_toolbox/version'
+require 'health_check_toolbox/health_check_routes'
+require 'health_check_toolbox/health_controller'
+require 'health_check_toolbox/config'
+require 'health_check_toolbox/status_manager'
+require 'health_check_toolbox/engine'
+require 'health_check_toolbox/services/redis_service'
+require 'health_check_toolbox/services/database'
+require 'health_check_toolbox/services/wso2'
+require 'health_check_toolbox/services/rest_services'
+
+module HealthCheckToolbox
+  def self.setup(&block)
+    config = Config.new(&block)
+    config.instance_eval(&block)
+  end
+end

data/lib/health_check_toolbox/config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module HealthCheckToolbox
+  class Config
+    @services = []
+
+    STATIC = %w[redis database wso2 rest_services].freeze
+    SERVICE = '_service'
+
+    class << self
+      attr_accessor :services
+
+      def add_service(service)
+        services.push(service)
+      end
+
+      def services_status
+        HealthCheckToolbox::StatusManager.generate(services)
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      method_name = method.to_s
+
+      if respond_to_missing?(method_name)
+        config_class =
+          "HealthCheckToolbox::Services::#{method_name.camelize}".constantize
+        service = config_class.new(args, block)
+        self.class.add_service(service)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name)
+      STATIC.include?(method_name.to_s) || method_name.include?(SERVICE)
+    end
+  end
+end

data/lib/health_check_toolbox/engine.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module HealthCheckToolbox
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/health_check_toolbox/health_check_routes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      def health_check_routes
+        match 'health_check(/:checks)(.:format)', to:
+          'health_check_toolbox/health#health_check', via: :get
+
+        match 'service_status(/:checks)(.:format)', to:
+          'health_check_toolbox/health#service_status', via: :get
+      end
+    end
+  end
+end

data/lib/health_check_toolbox/health_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module HealthCheckToolbox
+  class HealthController < ActionController::Base
+    def service_status
+      version = File.read('.version').chomp
+      render json: { ok: true, version: version }
+    end
+
+    def health_check
+      status = HealthCheckToolbox::Config.services_status
+      render json: {
+        timestamp: I18n.l(Time.current, format: :timestamp),
+        health_check: [status]
+      }
+    end
+  end
+end

data/lib/health_check_toolbox/services/base_health_check.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module HealthCheckToolbox
+  module Services
+    class BaseHealthCheck
+      attr_reader :args, :block
+
+      STATUS_OK = 'ok'
+      STATUS_ERROR = 'erro'
+
+      def initialize(args = nil, block = nil)
+        @args = args
+        @block = block
+      end
+
+      def build_response(condition)
+        condition ? STATUS_OK : STATUS_ERROR
+      end
+    end
+  end
+end

data/lib/health_check_toolbox/services/database.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'health_check_toolbox/services/base_health_check'
+
+module HealthCheckToolbox
+  module Services
+    class Database < HealthCheckToolbox::Services::BaseHealthCheck
+      def try_connect
+        ActiveRecord::Base.establish_connection
+        build_response(
+          begin
+            ActiveRecord::Base.connection_pool.with_connection do
+              ActiveRecord::Base.connection.active?
+            end
+          rescue StandardError
+            false
+          end
+        )
+      end
+    end
+  end
+end

data/lib/health_check_toolbox/services/redis_service.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'health_check_toolbox/services/base_health_check'
+require 'redis'
+
+module HealthCheckToolbox
+  module Services
+    class RedisService < HealthCheckToolbox::Services::BaseHealthCheck
+      def try_connect
+        build_response(
+          begin
+            Redis.new.ping
+            true
+          rescue StandardError
+            false
+          end
+        )
+      end
+    end
+  end
+end

data/lib/health_check_toolbox/services/rest_services.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'health_check_toolbox/services/base_health_check'
+require 'wso2_toolbox'
+require 'rest-client'
+
+module HealthCheckToolbox
+  module Services
+    class RestServices < HealthCheckToolbox::Services::BaseHealthCheck
+      attr_accessor :services
+
+      SERVICE = '_service'
+
+      def initialize(args, block)
+        super(args, block)
+        @services = []
+        instance_eval(&block)
+      end
+
+      # rubocop:disable Style/MissingRespondToMissing
+      def method_missing(method, *args)
+        method_name = method.to_s
+
+        if method_name.include?(SERVICE)
+
+          class_name = method_name.camelize
+
+          HealthCheckToolbox::Services.const_set(class_name, class_service)
+
+          services.push(
+            "HealthCheckToolbox::Services::#{class_name}".constantize.new(args)
+          )
+        else
+          super
+        end
+      end
+      # rubocop:enable Style/MissingRespondToMissing
+
+      # rubocop:disable Metrics/MethodLength
+      def class_service
+        Class.new(Object) do
+          attr_reader :url
+
+          def initialize(url)
+            @url = url.first
+          end
+
+          def try_connect
+            build_response(
+              begin
+                response = RestClient.get(url, headers)
+                response.code == 200
+              rescue StandardError
+                false
+              end
+            )
+          end
+
+          private
+
+          def headers
+            { 'Authorization' => Wso2Toolbox::TokenManager.generate_token,
+              'Content-Type' => 'application/json' }
+          end
+
+          def build_response(condition)
+            condition ? STATUS_OK : STATUS_ERROR
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/health_check_toolbox/services/wso2.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'health_check_toolbox/services/base_health_check'
+require 'wso2_toolbox'
+
+module HealthCheckToolbox
+  module Services
+    class Wso2 < HealthCheckToolbox::Services::BaseHealthCheck
+      def try_connect
+        build_response(
+          begin
+            Wso2Toolbox::TokenManager.generate_token
+            true
+          rescue StandardError
+            false
+          end
+        )
+      end
+    end
+  end
+end

data/lib/health_check_toolbox/status_manager.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module HealthCheckToolbox
+  class StatusManager
+    attr_reader :services
+
+    def self.generate(services)
+      new(services).generate
+    end
+
+    def initialize(services)
+      @services = services
+    end
+
+    def generate
+      statuses = {}
+      services.each.with_index(1) do |service, index|
+        status_index = "status_#{index}".to_sym
+
+        if service.respond_to?(:services)
+          services_block(service, index, statuses)
+        else
+          statuses[status_index] = status(service)
+        end
+      end
+      statuses
+    end
+
+    private
+
+    def status(service)
+      "#{service_name(service)}:#{service.try_connect}"
+    end
+
+    def service_name(service)
+      service.class.name.split('::').last.underscore
+    end
+
+    def services_block(element, index, statuses)
+      cont = index
+
+      element.services.each do |service|
+        status_index = "status_#{cont > index ? cont : index}".to_sym
+        statuses[status_index] = status(service)
+        cont += 1
+      end
+    end
+  end
+end

data/lib/health_check_toolbox/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HealthCheckToolbox
+  VERSION = '1.0.1'
+end