kybus-server 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 241297935e3c516fad7194a56e888e6c2a1d8b140b11c5a1cd7ddfb4ec7b4778
+  data.tar.gz: 3f5d6d82a0b055e8857d3bde6cb566a13c6ca48ad59bbfbb4576cabd5612b219
+SHA512:
+  metadata.gz: 223cbfa1a4a00e252c18f94b0669257e7b6293297fcc7a61ac864208c5deb5569a41c1df1dfbead272322450a9d7c5f2b7e62b576b4c45993c1be105d191c3eb
+  data.tar.gz: c68a165e527a0b66f6c9730dd818e21785b4d17049b4d9b15c1654fafcb620141e379b4a0522edf7c6801e8805d6ab966f4de8e5e3888f4d3a50d0f0d8f7e914

data/lib/kybus/server.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'kybus/core'
+
+require_relative 'version'
+require_relative 'server/response'
+require_relative 'server/format'

data/lib/kybus/server/format.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Server
+    ##
+    # See Exceptions module, since this is based on the exceptions too.
+    # This will wrap a json object into a standard format, where the response
+    # will contain some metadata about the status of the request
+    class Format
+      INTERNAL_SERVER_ERROR_CODE = 'INTERNAL_SERVER_ERROR'
+      INTERNAL_SERVER_ERROR_MESSAGE = 'Unexpected error ocurred!'
+      ##
+      # success means there were no errors during the execution of the request
+      # it sends the result in the data field.
+      def success(response)
+        { status: :success, data: response.result || response.data }
+      end
+
+      ##
+      # an error on the request. It gives the details of the error.
+      def fail(response)
+        error_format(:fail, response.code, response.message, response.data)
+      end
+
+      ##
+      # an error found while resolving the request.
+      def error(response)
+        error_format(:error, response.code, response.message, response.data)
+      end
+
+      ##
+      # an unhandled error ocurred during the execution of the request.
+      def fatal(_data)
+        error_format(:fatal, INTERNAL_SERVER_ERROR_CODE,
+                     INTERNAL_SERVER_ERROR_MESSAGE, {})
+      end
+
+      ##
+      # helper to sumarize fatal and error status
+      def error_format(level, code, message, data)
+        { status: level, code: code, message: message, data: data }
+      end
+    end
+  end
+end

data/lib/kybus/server/grape.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Server
+    # Descorator for using grape with kybus.
+    # This will implement:
+    # - exception handling
+    # - logs
+    # - JSend format
+    module GrapeDecorator
+      def self.handler
+        lambda do |env, level, ex|
+          params = env['api.endpoint'].params
+          request = env['api.endpoint'].request
+          pkg = RequestResponse.new(request: request, params: params)
+          pkg.exception = ex
+          Server::Response.logger.send(level, pkg)
+          Server::Response.format.send(level, pkg)
+        end
+      end
+
+      HTTP_CODES = {
+        success: 200, fail: 400, error: 500, fatal: 500
+      }.freeze
+
+      def self.extract_http_code(exception, level)
+        default = HTTP_CODES[level] || 500
+        exception.respond_to?(:http_code) ? exception.http_code : default
+      end
+
+      def self.configure_custom_exceptions(base)
+        Server::Response.resources(:exceptions).each do |exception_class, level|
+          base.rescue_from(exception_class) do |ex|
+            response = Kybus::Server::GrapeDecorator.handler.call(env, level, ex)
+            http_code = Kybus::Server::GrapeDecorator.extract_http_code(ex, level)
+            error!(response, http_code)
+          end
+        end
+      end
+
+      # :nocov: #
+      def self.configure_grape_exceptions(base)
+        base.rescue_from(Grape::Exceptions::Base) do |ex|
+          ant_ex = Kybus::Exceptions::AntFail.new(ex.message)
+          response = Kybus::Server::GrapeDecorator
+                     .handler.call(env, :fail, ant_ex)
+          error!(response, 400)
+        end
+      end
+      # :nocov: #
+
+      def self.configure_global_exception_handler(base)
+        base.rescue_from(:all) do |ex|
+          level = :fatal
+          response = Kybus::Server::GrapeDecorator.handler.call(env, level, ex)
+          http_code = Kybus::Server::GrapeDecorator.extract_http_code(ex, level)
+          error!(response, http_code)
+        end
+      end
+
+      def self.configure_handlers(base)
+        configure_custom_exceptions(base)
+        configure_grape_exceptions(base)
+        configure_global_exception_handler(base)
+      end
+
+      def self.included(base)
+        base.formatter(:json, lambda do |response, _|
+          pkg = RequestResponse.new(request: {}, params: {})
+          pkg.result = response
+          Server::Response.format.send(:success, pkg).to_json
+        end)
+        configure_logger(base)
+        configure_handlers(base)
+      end
+
+      def self.configure_logger(base)
+        base.before do
+          params[:__init_time] = Time.now
+        end
+        base.after do
+          params = env['api.endpoint'].params
+          request = env['api.endpoint'].request
+          pkg = RequestResponse.new(request: request, params: params)
+          Server::Response.logger.access(pkg)
+        end
+      end
+    end
+  end
+end

data/lib/kybus/server/logger.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'kybus/logger'
+module Kybus
+  module Server
+    # Implements monitoring. This will add logs.
+    # Currently it only support CuteLogger format, but it will be deprecated
+    # in order to support a new log (actually kind of the same format).
+    class Logger
+      include Kybus::Logger
+      def access_data(response)
+        {
+          path: response.path,
+          ip: response.ip,
+          verb: response.verb,
+          processing_time:
+            (Time.now - response.params[:__init_time]).to_f * 1000
+        }
+      end
+
+      def access(response)
+        log_info('Requesting resource', access_data(response))
+      end
+
+      def success(response)
+        log_info('Success request', access_data(response))
+      end
+
+      def fail(response)
+        log_info('Fail Response',
+                 access_data(response)
+                  .merge(message: response.exception.message))
+      end
+
+      def error(response)
+        log_warn('Error dectected on response', access_data(response).merge(
+                                                  error: response.exception
+                                                ))
+      end
+
+      def fatal(response)
+        log_error('Unexpected error on response',
+                  access_data(response).merge(
+                    error: response.exception,
+                    data: response.params,
+                    trace: response.exception.backtrace
+                  ))
+      end
+    end
+  end
+end

data/lib/kybus/server/request_response.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Server
+    # Wraps the request and the response into an object so it is easier
+    # to track monitoring logs and format the response after the endpoint was
+    # executed
+    class RequestResponse
+      attr_reader :params, :exception, :result, :start_timestamp
+      attr_writer :exception, :result, :start_timestamp
+      def initialize(request:, params:)
+        @request = request
+        @params = params
+        @start_timestamp = Time.now
+      end
+
+      def data
+        @exception.data
+      end
+
+      def code
+        @exception.code
+      end
+
+      def verb
+        @request.request_method
+      end
+
+      def ip
+        @request.ip
+      end
+
+      def message
+        @exception.message
+      end
+
+      def path
+        @request.env['PATH_INFO']
+      end
+    end
+  end
+end

data/lib/kybus/server/response.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'format'
+require_relative 'logger'
+require_relative 'request_response'
+
+module Kybus
+  module Server
+    ##
+    # This module provides a function to wrap lambdas arround grape/sinatra
+    # You can mount this module as helper in your application and wrap the block
+    # with the method `process_request`
+    module Response
+      include Exceptions
+      extend DRY::ResourceInjector
+
+      class << self
+        attr_reader :logger, :format
+
+        def log_mode(mode)
+          @logger = resource(:loggers, mode)
+        end
+
+        def format_mode(mode)
+          @format = resource(:formats, mode)
+        end
+
+        def recover_from!(exception_class, level)
+          register(:exceptions, exception_class, level)
+        end
+
+        def configure_defaults!
+          recover_from!(Exceptions::AntSuccess, :success)
+          recover_from!(Exceptions::AntFail, :fail)
+          recover_from!(Exceptions::AntError, :error)
+          register(:loggers, :cute_logger, Server::Logger.new)
+          register(:formats, :jsend, Server::Format.new)
+          log_mode(:cute_logger)
+          format_mode(:jsend)
+        end
+      end
+
+      def exception_handler(exception)
+        Server::Response.resources(:exceptions).each do |klass, recover|
+          return recover if exception.is_a?(klass)
+        end
+        exception.is_a?(StandardError) ? :fatal : nil
+      end
+
+      def handle(resolver, data)
+        if resolver
+          Server::Response.logger.send(resolver, data)
+          Server::Response.format.send(resolver, data)
+        else
+          Server::Response.logger.fatal(data)
+          raise(data.exception)
+        end
+      end
+
+      def process_request
+        params[:__init_time] = Time.now
+        data = RequestResponse.new(request: request, params: params)
+        resolver = :success
+        Server::Response.logger.access(data)
+        begin
+          raise(AntError, 'No implementation given') unless block_given?
+
+          data.result = yield
+          # rubocop: disable Lint/RescueException
+        rescue Exception => e
+          # rubocop: enable Lint/RescueException
+          data.exception = e
+          resolver = exception_handler(e)
+        end
+        handle(resolver, data)
+      end
+    end
+  end
+end
+
+# Allow backwards compatibility
+Kybus::Server::Response.configure_defaults!

data/lib/kybus/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kybus
+  module Server
+    VERSION = '0.1.1'
+  end
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: kybus-server
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Gilberto Vargas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kybus-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: kybus-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: grape
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rack-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: This gems can be used along a server app with jsonformat messages
+email:
+- tachoguitar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kybus/server.rb
+- lib/kybus/server/format.rb
+- lib/kybus/server/grape.rb
+- lib/kybus/server/logger.rb
+- lib/kybus/server/request_response.rb
+- lib/kybus/server/response.rb
+- lib/kybus/version.rb
+homepage: https://github.com/tachomex/kybus
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Implements Kybus format on server applications
+test_files: []