minato_error_handler 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dc9c58925db88b167dada6c2d68e633403a0c3bafe95ef8d3f55f445c8ae0a3
-  data.tar.gz: 1eb7c12bbb02ec88019476c6062eeb49d1e496c6778488c706e5057f58abf4b9
+  metadata.gz: 988d987bdc7a0593533084b7fc83288fe7f64ece3cfeba4594db9b4a8532b56b
+  data.tar.gz: 8119087acb2dfc744d0aa02451f2a9d1b9132f85fcc598124b09d364d25136dc
 SHA512:
-  metadata.gz: eaf3b474dbb49763a751e05e32ee7ba108e5a504d07cebd0d14b5064fe1551b3d60e05f8a1d3d8441678b195e5a346da21dd5dad221f671e5b36218631a3e1e8
-  data.tar.gz: 8239f273e1dab47c46aea4216793d30b46c236197bb85a10ff380c0e04d1c2914f2a3c030e15d0735e7257fb9dd260439a233929e4001de7fb54ebdd56a51d23
+  metadata.gz: 2d8820cace6d1019446059434765cae6918207f6bc0642bac9f07d29134dabe47684448f6f902ade6a650d79eba636b79d31fdd7f629bcbeac518fad798bc352
+  data.tar.gz: de8b0ba7c9fe5345854e69339d77949d869ec2e03c360f56af6fcfc8f75a8f0a21595db942a3f92e8cd08dfdd9ec4af6d5862de5b948b616b89c3706e9e88dba

data/lib/minato_error_handler/error_handler.rb

@@ -1,26 +1,72 @@
 # frozen_string_literal: true
 
-require "minato_logger"
-
 module MinatoErrorHandler
   module ErrorHandler
     extend ActiveSupport::Concern
 
-    included do
+    included do |base|
       rescue_from StandardError, with: :handle
+
+      base.extend ClassMethods
     end
 
     private
 
     def handle(exception)
-      error = MinatoErrorHandler::MinatoError.from_error(exception)
-      report_error(error)
-      render json: { errors: [error.to_json] }, status: error.status_code
+      error = parse_error(exception)
+      report_error error
+      render_error error
+    end
+
+    def parse_error(error)
+      return parse_minato_error(error) if minato_error?(error)
+
+      build_minato_error(error)
+    end
+
+    def parse_minato_error(error)
+      error.http_request ||= request
+      error.http_response ||= response
+      error
+    end
+
+    def minato_error?(error)
+      error.is_a?(MinatoErrorHandler::Errors::MinatoError)
+    end
+
+    def error_class
+      self.class.default_error_class || MinatoErrorHandler::Errors::UnknowError
+    end
+
+    def build_minato_error(error)
+      minato_error = error_class.new
+      minato_error.caused_by = error.full_message
+      minato_error.backtrace = error.backtrace
+      minato_error.http_request ||= request
+      minato_error.http_response ||= response
+      minato_error
     end
 
     def report_error(error)
-      logger = MinatoLogger::Logger.new
-      logger.error(error.to_json)
+      Rails.logger.error(error.as_json)
+    end
+
+    def render_error(error)
+      render json: { errors: [error.json_response] }, status: error.status_code
+    end
+
+    module ClassMethods
+      def default_error(klass)
+        # rubocop:disable Style/ClassVars
+        class_variable_set(:@@default_error_class, klass.to_s.camelize.constantize)
+        # rubocop:enable Style/ClassVars
+      end
+
+      def default_error_class
+        return nil unless class_variable_defined? :@@default_error_class
+
+        class_variable_get(:@@default_error_class)
+      end
     end
   end
 end

data/lib/minato_error_handler/errors/minato_error.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+
+module MinatoErrorHandler
+  module Errors
+    class MinatoError < StandardError
+      attr_accessor :caused_by, :details, :debug_details
+      attr_reader :http_request, :http_response
+
+      def message
+        raise_method_not_implemented_error __method__
+      end
+
+      def error_reporting_type
+        "type.googleapis.com/google.devtools.clouderrorreporting.v1beta1.ReportedErrorEvent"
+      end
+
+      def status_code
+        raise_method_not_implemented_error __method__
+      end
+
+      def code
+        self.class.name
+      end
+
+      def backtrace=(backtrace)
+        set_backtrace(backtrace)
+      end
+
+      def unique_identifier
+        @unique_identifier ||= SecureRandom.uuid
+      end
+
+      def to_json(*_args)
+        serialized_hash(serializable_methods_to_log).to_json
+      end
+
+      def as_json
+        serialized_hash(serializable_methods_to_log).as_json
+      end
+
+      def json_response
+        serialized_hash(serializable_methods_to_response).as_json
+      end
+
+      def http_request=(req)
+        return if req.nil?
+
+        @http_request = { headers: parse_http_request_headers(req.headers), host: req.host,
+                          method: req.request_method, path: req.path, query: req.query_parameters,
+                          remote: req.remote_ip, scheme: req.scheme }
+      end
+
+      def http_response=(res)
+        return if res.nil?
+
+        @http_response = { headers: parse_http_response_headers(res.headers),
+                           status: res.status,
+                           text_status: res.status_message }
+      end
+
+      def stack_trace
+        backtrace
+      end
+
+      private
+
+      def serializable_methods_to_log
+        %i[caused_by code details debug_details message http_request
+           http_response status_code unique_identifier stack_trace @type]
+      end
+
+      def serializable_methods_to_response
+        methods_to_exclude = %i[http_request http_response stack_trace debug_details]
+        serializable_methods_to_log.reject { |m| methods_to_exclude.include? m }
+      end
+
+      def serialized_hash(methods)
+        data = {}
+        methods.each do |method|
+          if method == :@type
+            data["@type"] = error_reporting_type
+          else
+            data[method] = send(method)
+          end
+        end
+        data
+      end
+
+      def parse_http_request_headers(headers)
+        selected_headers = headers.env.filter { |k, _v| k.upcase.start_with? "HTTP" }
+        selected_headers.transform_keys! { |k| k.gsub(/\bHTTP_/, "").downcase }
+        selected_headers
+      end
+
+      def parse_http_response_headers(headers)
+        headers.transform_keys(&:downcase)
+      end
+
+      def raise_method_not_implemented_error(method_name)
+        raise "You must define \"#{method_name}\" in your concrete class."
+      end
+    end
+  end
+end

data/lib/minato_error_handler/errors/network_error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MinatoErrorHandler
+  module Errors
+    class NetworkError < MinatoErrorHandler::Errors::MinatoError
+      attr_accessor :req, :res
+
+      def initialize(req: nil, res: nil)
+        @req = req
+        @res = res
+        super()
+      end
+
+      def message
+        "A network error has occurred!"
+      end
+
+      def status_code
+        503
+      end
+
+      def debug_details
+        { request: req, response: res }
+      end
+    end
+  end
+end

data/lib/minato_error_handler/errors/unknow_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MinatoErrorHandler
+  module Errors
+    class UnknowError < MinatoError
+      def message
+        "An unknow error has occurred! See more details in caused_by field."
+      end
+
+      def status_code
+        500
+      end
+    end
+  end
+end

data/lib/minato_error_handler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MinatoErrorHandler
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/minato_error_handler.rb

@@ -2,6 +2,7 @@
 
 require "minato_error_handler/railtie"
 require "minato_error_handler/version"
-require "minato_error_handler/minato_error"
-require "minato_error_handler/network_error"
+require "minato_error_handler/errors/minato_error"
+require "minato_error_handler/errors/network_error"
+require "minato_error_handler/errors/unknow_error"
 require "minato_error_handler/error_handler"

data/minato_error_handler.gemspec

@@ -32,7 +32,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "minato_logger", "~>0.1.6"
   spec.add_dependency "rails", ">= 7.0.4"
 
   # Uncomment to register a new dependency of your gem

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: minato_error_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Ferreri
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-28 00:00:00.000000000 Z
+date: 2024-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: minato_logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.6
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +24,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 7.0.4
-description: 
+description:
 email:
 - contato@ferreri.co
 executables: []
@@ -57,8 +43,9 @@ files:
 - compose.yml
 - lib/minato_error_handler.rb
 - lib/minato_error_handler/error_handler.rb
-- lib/minato_error_handler/minato_error.rb
-- lib/minato_error_handler/network_error.rb
+- lib/minato_error_handler/errors/minato_error.rb
+- lib/minato_error_handler/errors/network_error.rb
+- lib/minato_error_handler/errors/unknow_error.rb
 - lib/minato_error_handler/railtie.rb
 - lib/minato_error_handler/version.rb
 - minato_error_handler.gemspec
@@ -71,7 +58,7 @@ metadata:
   source_code_uri: https://gitlab.com/ferreri/minato/minato_error_handler
   changelog_uri: https://gitlab.com/ferreri/minato/minato_error_handler/-/blob/main/CHANGELOG.md?ref_type=heads
   rubygems_mfa_required: 'false'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +73,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Error reporting for Minato Rails Apps.
 test_files: []

data/lib/minato_error_handler/minato_error.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "json"
-
-module MinatoErrorHandler
-  class MinatoError < StandardError
-    def initialize(details: {}, caused_by: nil, status_code: 500)
-      @caused_by = caused_by
-      @details = details
-      @status_code = status_code
-      super
-    end
-
-    def self.from_error(error)
-      return error if error.is_a?(MinatoErrorHandler::MinatoError)
-
-      new caused_by: error.cause
-    end
-
-    attr_reader :details, :status_code
-
-    def message
-      "An unknow error has occurred!"
-    end
-
-    def code
-      self.class.name
-    end
-
-    def unique_identfier
-      @unique_identfier || SecureRandom.uuid
-    end
-
-    def caused_by
-      @caused_by || cause
-    end
-
-    def serialized_hash
-      { message: message, code: code, unique_identfier: unique_identfier,
-        details: details, caused_by: caused_by, status_code: status_code }
-    end
-
-    def to_json(*_args)
-      serialized_hash.as_json
-    end
-  end
-end

data/lib/minato_error_handler/network_error.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module MinatoErrorHandler
-  class NetworkError < MinatoErrorHandler::MinatoError
-    def initialize(details: {}, caused_by: nil, status_code: nil, request_body: {})
-      @request_body = request_body
-      super(details: details, caused_by: caused_by, status_code: status_code)
-    end
-
-    attr_reader :request_body
-
-    def message
-      "A network error has occurred!"
-    end
-
-    def serialized_hash
-      super.merge({ request_body: request_body })
-    end
-  end
-end