hcheck 0.1.0

data/lib/hcheck.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'erb'
+require 'logger'
+
+require 'hcheck/version'
+require 'hcheck/helper'
+require 'hcheck/application'
+require 'hcheck/configuration'
+require 'hcheck/errors'
+
+# Main Hcheck module
+module Hcheck
+  class << self
+    attr_accessor :configuration, :logging
+
+    LOG_FILE_PATH = 'log/hcheck.log'
+
+    def status
+      if configuration
+        configuration.services.map(&:check)
+      else
+        [{
+          name: 'Hcheck',
+          desc: 'Hcheck',
+          status: 'Hcheck configuration not found'
+        }]
+      end
+    end
+
+    def configure(config = {})
+      self.configuration ||= Configuration.new(config)
+    end
+
+    def logger
+      self.logging ||= set_logger
+    end
+
+    private
+
+    def set_logger
+      dir = File.dirname(LOG_FILE_PATH)
+      FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      logger = Logger.new(LOG_FILE_PATH, 'daily')
+      logger.formatter = proc do |severity, datetime, _progname, msg|
+        log_msg = "[#{severity}] [#{datetime}] #{msg}"
+        puts log_msg
+        "#{log_msg}\n"
+      end
+      logger
+    end
+  end
+end

data/lib/hcheck/application.rb

@@ -0,0 +1,42 @@
+require 'sinatra'
+require 'haml'
+
+require 'hcheck'
+require 'hcheck/application/helpers/responders'
+
+module Hcheck
+  # base sinatra application
+  class SinatraBase < Sinatra::Base
+    set :public_dir, File.expand_path('application/assets', __dir__)
+    set :views, File.expand_path('application/views', __dir__)
+    set :haml, format: :html5
+
+    include Hcheck::ApplicationHelpers::Responders
+  end
+
+  # sinatra that gets booted when run in standalone mode
+  class Application < SinatraBase
+    get('/hcheck') { h_status }
+  end
+
+  # sinatra when mounted to rails
+  class Status < SinatraBase
+    def initialize(app = nil)
+      Hcheck::Configuration.load_default
+    rescue Hcheck::Errors::ConfigurationError => e
+      @config_error = e
+    ensure
+      super(app)
+    end
+
+    get('/') do
+      if @config_error
+        Hcheck.logger.error @config_error.message
+
+        respond_with Hcheck::Errors::ConfigurationError::MSG, 500, :error
+      else
+        h_status
+      end
+    end
+  end
+end

data/lib/hcheck/application/helpers/responders.rb

@@ -0,0 +1,55 @@
+module Hcheck
+  module ApplicationHelpers
+    # Sinatra app controller helpers
+    module Responders
+      module_function
+
+      def h_status
+        authenticate!(params) if secured_access_enabled?
+
+        @status = Hcheck.status
+
+        if @status.find { |s| s[:status] == 'bad' }
+          status 503
+        else
+          status 200
+        end
+
+        haml :index
+      rescue Hcheck::Errors::InvalidAuthentication, Hcheck::Errors::IncompleteAuthSetup => e
+        status 401
+        @msg = e.message
+
+        haml :error
+      end
+
+      def respond_with(message, status_code, view)
+        status status_code
+        @msg = message
+
+        haml view
+      end
+
+      private
+
+      def secured_access_enabled?
+        ENV['HCHECK_SECURE']
+      end
+
+      def authenticate!(params)
+        @token = params[:token]
+        access_precheck!
+
+        raise Hcheck::Errors::InvalidAuthentication unless ENV['HCHECK_ACCESS_TOKEN'].eql?(@token)
+      end
+
+      def access_precheck!
+        # throw error when hcheck secure is enabled but token is not set yet
+        raise Hcheck::Errors::IncompleteAuthSetup unless ENV['HCHECK_ACCESS_TOKEN'].present?
+
+        # throw error when token is not sent
+        raise Hcheck::Errors::InvalidAuthentication unless @token.present?
+      end
+    end
+  end
+end

data/lib/hcheck/application/views/error.haml

@@ -0,0 +1,26 @@
+%table.table
+  %tbody
+    %tr
+      %td
+        .error= @msg
+:css
+  body {
+    background: #fefefe;
+    font-family: sans-serif;
+  }
+  .table {
+    width: 1024px;
+    margin: 0 auto;
+  }
+  .table td, .table th {
+    padding: 12px;
+    font-weight: 200;
+    text-align: center;
+  }
+  .table th {
+    font-size: 2em;
+    padding: 20px;
+  }
+  .error {
+    color: red
+  }

data/lib/hcheck/application/views/index.haml

@@ -0,0 +1,38 @@
+%table.table
+  %thead
+    %tr
+      %th{ colspan: 3 } Hcheck Status Page
+  %tbody
+    - @status.each do |s|
+      %tr
+        %td
+          #{s[:name]}
+        %td
+          #{s[:desc]}
+        %td
+          - case s[:status]
+            - when 'ok'
+              %span{style: 'color: green'} Ok
+            - when 'bad'
+              %span{style: 'color: red'} Bad
+            - else
+              %span{style: 'color: orange'}= s[:status]
+
+:css
+  body {
+    background: #fefefe;
+    font-family: sans-serif;
+  }
+  .table {
+    width: 1024px;
+    margin: 0 auto;
+  }
+  .table td, .table th {
+    padding: 12px;
+    text-transform: capitalize;
+    font-weight: 200;
+  }
+  .table th {
+    font-size: 2em;
+    padding: 20px;
+  }

data/lib/hcheck/checks/memcached.rb

@@ -0,0 +1,22 @@
+module Hcheck
+  module Checks
+    # memcached check module
+    # implements status
+    # include memcached check dependencies
+    module Memcached
+      # @config { hosts, user, password }
+      def status(config)
+        client = Dalli::Client.new(config.delete(:url), config)
+        client.get('_')
+        'ok'
+      rescue Dalli::RingError => e
+        Hcheck.logger.error "[HCheck] Memcached::Error::NoServerAvailable #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'dalli'
+      end
+    end
+  end
+end

data/lib/hcheck/checks/mongodb.rb

@@ -0,0 +1,26 @@
+module Hcheck
+  module Checks
+    # mongodb check module
+    # implements status
+    # include mongodb check dependencies
+    module Mongodb
+      # @config { hosts, user, password }
+      def status(config)
+        mongo_config = config.merge(connect_timeout: 3)
+        hosts = mongo_config.delete(:hosts).compact
+        client = Mongo::Client.new(hosts, mongo_config.merge(server_selection_timeout: hosts.count * 2))
+        client.database_names
+        client.close
+        'ok'
+      rescue Mongo::Error::NoServerAvailable => e
+        Hcheck.logger.error "[HCheck] Mongo::Error::NoServerAvailable #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'mongo'
+        Mongo::Logger.level = Logger::INFO
+      end
+    end
+  end
+end

data/lib/hcheck/checks/mysql.rb

@@ -0,0 +1,22 @@
+module Hcheck
+  module Checks
+    # mysql check module
+    # implements status
+    # include mysql check dependencies
+    module Mysql
+      # @config { host, port, username, password, database }
+      def status(config)
+        connection = Mysql2::Client.new(config)
+        connection.close
+        'ok'
+      rescue Mysql2::Error => e
+        Hcheck.logger.error "[HCheck] Mysql2::Error::ConnectionError #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'mysql2'
+      end
+    end
+  end
+end

data/lib/hcheck/checks/ping.rb

@@ -0,0 +1,38 @@
+module Hcheck
+  module Checks
+    # ping check module
+    # implements status
+    # include ping check dependencies
+    # returns ok only if the response code is 2** or 3**
+    module Ping
+      # @config { url }
+      def status(config)
+        url = URI.parse(config[:url])
+        request = build_request(url)
+
+        case request.request_head(url.path)
+        when Net::HTTPSuccess, Net::HTTPRedirection, Net::HTTPInformation
+          'ok'
+        else
+          'bad'
+        end
+      rescue Net::ReadTimeout, Errno::ECONNREFUSED => e
+        Hcheck.logger.error "[HCheck] Ping Fail #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'net/http'
+      end
+
+      def build_request(url)
+        req = Net::HTTP.new(url.host, url.port)
+        req.use_ssl = true if url.scheme == 'https'
+        req.read_timeout = 5 # seconds
+
+        url.path = '/' if url.path.empty?
+        req
+      end
+    end
+  end
+end

data/lib/hcheck/checks/postgresql.rb

@@ -0,0 +1,24 @@
+module Hcheck
+  module Checks
+    # postgresql check module
+    # implements status
+    # include postgresql check dependencies
+    module Postgresql
+      # @config { host, port, options, tty, dbname, user, password }
+      def status(config)
+        config[:user] = config.delete(:username) if config[:username]
+        config[:dbname] = config.delete(:database) if config[:database]
+
+        PG::Connection.new(config).close
+        'ok'
+      rescue PG::ConnectionBad => e
+        Hcheck.logger.error "[HCheck] PG::ConnectionBad #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'pg'
+      end
+    end
+  end
+end

data/lib/hcheck/checks/rabbitmq.rb

@@ -0,0 +1,29 @@
+module Hcheck
+  module Checks
+    # rabbitmq check module
+    # implements status
+    # include rabbitmq check dependencies
+    module Rabbitmq
+      # @config { host, vhost, port, user, pass }
+      def status(config)
+        connection = Bunny.new(config)
+        connection.start
+        connection.close
+        'ok'
+      rescue Bunny::TCPConnectionFailed,
+             Bunny::TCPConnectionFailedForAllHosts,
+             Bunny::NetworkFailure,
+             Bunny::AuthenticationFailureError,
+             Bunny::PossibleAuthenticationFailureError,
+             AMQ::Protocol::EmptyResponseError => e
+
+        Hcheck.logger.error "[HCheck] Bunny::Error #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'bunny'
+      end
+    end
+  end
+end

data/lib/hcheck/checks/redis.rb

@@ -0,0 +1,23 @@
+module Hcheck
+  module Checks
+    # redis check module
+    # implements status
+    # include redis check dependencies
+    module Redis
+      # @config { host, port, db, password }
+      def status(config)
+        config[:sentinels] = config[:sentinels].map(&:symbolize_keys) if config[:sentinels]
+
+        ::Redis.new(config).ping
+        'ok'
+      rescue ::Redis::CannotConnectError => e
+        Hcheck.logger.error "[HCheck] Redis server unavailable #{e.message}"
+        'bad'
+      end
+
+      def self.included(_base)
+        require 'redis'
+      end
+    end
+  end
+end

data/lib/hcheck/configuration.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'hcheck/configuration/service'
+
+module Hcheck
+  # configuration class that loads configs via various ways
+  # initializes service classes from config
+  class Configuration
+    attr_reader :services
+    DEFAULT_HCHECK_DIR = Gem.loaded_specs['rails'] ? 'config/' : ''
+    DEFAULT_CONFIG_PATH = [DEFAULT_HCHECK_DIR, 'hcheck.yml'].join
+
+    def initialize(config)
+      @services = config.map do |key, options|
+        options = [options] unless options.is_a?(Array)
+        options.map { |o| Service.new(key, o) }
+      end.flatten
+    end
+
+    class << self
+      def load(config)
+        Hcheck.configure config
+      end
+
+      def load_argv(args)
+        load_file(args[1].strip) if argv_config_present?(args)
+      end
+
+      def load_file(path)
+        load read(path)
+      end
+
+      def load_default
+        load_file(DEFAULT_CONFIG_PATH)
+      end
+
+      def read(path)
+        YAML.safe_load(ERB.new(File.read(path)).result, [Symbol]) || {}
+      rescue StandardError => e
+        raise Hcheck::Errors::ConfigurationError, e
+      end
+
+      def generate_config
+        FileUtils.copy_file(Gem.loaded_specs['hcheck'].gem_dir + '/hcheck.sample.yml', DEFAULT_CONFIG_PATH)
+        puts "Generated #{DEFAULT_CONFIG_PATH}"
+      end
+
+      private
+
+      def argv_config_present?(argvs)
+        !argvs.empty? && argvs[0].match(/-+(config|c)/i)
+      end
+    end
+  end
+end