moromi-error 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3b3488c51946c8ca81848716ba4a10bb6e04143f
-  data.tar.gz: a134a2a13ba6306c7524ede717a153db476979da
+SHA256:
+  metadata.gz: 5936263f9533c71c7ff02f65e8edc1e443969de98a74cbf87a49735d9877a77f
+  data.tar.gz: c4909ef90986ab0807fd01609ebd36566ce4ddd563a00b526f08262b91d66ff2
 SHA512:
-  metadata.gz: 41b6e64b0dacb938aff65776baea13db6b1de7eb209104823bd1498d6a58368984c0e8c01a2140af38d47c16d50d6552f3978c8c83420034ba88494ba8dd8a63
-  data.tar.gz: 6c5f2fccb3d3755bfc22af75d903e15afcaa1fd720ed4666618817f27e6d6d5592dfe453885d71a9aeacbf57af8e66698a0d14f520ce95c38d942d00f35b39b1
+  metadata.gz: 3b24ea60d59cfe2a2b0740dd373480677fdacce3cfa2e776a3753533f3a09c160f82a8a72d89e487f8550c9ecf9617fa35fd19cd7d3943b157af679cef7bbf21
+  data.tar.gz: 4154adddd34af2fe8108536b41d5d960f683cae47996fcee64dd7e81f400eb02c7ce0133684dd6a2f8a9073b1bfb9fc7c4e6f9aa3ca431dab96c60d91ce68221

data/.github/workflows/release.yml

@@ -0,0 +1,33 @@
+name: Release gem
+
+on:
+  workflow_dispatch:
+    inputs:
+      rubygems-otp-code:
+        description: RubyGems OTP code
+        required: true
+
+permissions:
+  contents: write
+
+jobs:
+  release-gem:
+    runs-on: ubuntu-latest
+    env:
+      GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+      GEM_HOST_OTP_CODE: ${{ github.event.inputs.rubygems-otp-code }}
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0 # bundle exec rake release で git tag を見るため、tagをfetchするようにしている
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1.1
+      - name: Bundle install
+        run: bundle install
+      - name: Setup git config # bundle exec rake release でgit tagが打たれていない場合、タグを打ってpushしてくれるため用意している
+        run: |
+          git config --global user.email "taka0125@gmail.com"
+          git config --global user.name "Takahiro Ooishi"
+      - name: Release gem
+        run: bundle exec rake release

data/.github/workflows/ruby.yml

@@ -0,0 +1,23 @@
+name: Ruby
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        ruby: [2.7, 3.0]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - run: |
+          gem install bundler
+          bundle config path vendor/bundle
+          bundle install --jobs 4 --retry 3
+          bundle exec rspec

data/.gitignore

@@ -7,5 +7,6 @@ spec/dummy/log/*.log
 spec/dummy/tmp/
 
 vendor/bundle
+vendor/bin
 Gemfile.lock
 

data/README.md

@@ -1,8 +1,7 @@
 # Moromi::Error
 
 [![Latest Version](https://img.shields.io/gem/v/moromi-error.svg)](http://rubygems.org/gems/moromi-error)
-[![Circle CI](https://circleci.com/gh/moromi/moromi-error.svg?style=svg)](https://circleci.com/gh/moromi/moromi-error)
-
+[![Build Status](https://github.com/moromi/moromi-error/workflows/Ruby/badge.svg)](https://github.com/moromi/moromi-error/actions)
 Error templates.
 
 ## Installation
@@ -30,7 +29,6 @@ Or install it yourself as:
 ```ruby
 Moromi::Error.configure do |config|
   config.debug = true
-  config.store_url = 'https://itunes.apple.com/jp/app/idxxxxxxxxxx'
 end
 ```
 
@@ -55,13 +53,13 @@ it's optional module.
 
 ### Copy Template
 
-- jbuilder and erb
+- jb and jbuilder and erb
 
 ```ruby
 bundle exec rails g moromi:error:views -e erb
 ```
 
-- jbuilder and slim
+- jb and jbuilder and slim
 
 ```ruby
 bundle exec rails g moromi:error:views -e slim

data/app/views/moromi/error/{_default.html.slim → default.html.slim}

@@ -8,6 +8,8 @@ html lang="ja"
   body
     div
       h1= "#{status} #{title}"
+      p= "RequestId: #{request.uuid}"
+      p= exception.error_title
 
       - unless Rails.env.production?
         table
@@ -18,8 +20,17 @@ html lang="ja"
             tr
               td debug_message
               td= exception.debug_message
+            tr
+              td detail_url
+              td= exception.detail_url
 
             - exception.errors.each do |error|
               tr
                 td error
                 td= error
+
+            tr
+              td backtrace
+              td
+                - backtrace = exception.backtrace.presence || exception.original_exception&.backtrace || []
+                pre= safe_join(::Rails.backtrace_cleaner.clean(backtrace), '<br />'.html_safe)

data/app/views/moromi/error/default.json.jb

@@ -0,0 +1,9 @@
+{
+  status: status,
+  title: title,
+  code: exception.code,
+  detail_url: exception.detail_url,
+  debug_message: exception.debug_message,
+  error_title: exception.error_title,
+  errors: exception.errors
+}

data/app/views/moromi/error/{_force_update.json.jbuilder → default.json.jbuilder}

@@ -1,6 +1,7 @@
 json.status status
-json.code exception.code
 json.title title
-json.store_url exception.store_url
+json.code exception.code
+json.detail_url exception.detail_url
 json.debug_message exception.debug_message
+json.error_title exception.error_title
 json.errors exception.errors

data/config/locales/moromi-error.yml

@@ -1,18 +1,20 @@
 en:
   strings:
     moromi-error:
-      an_error_has_occurred: 'An error has occurred.'
-      validation_error: 'Validation error.'
-      not_found: 'Not found.'
-      permission_denied: 'Permission denied.'
-      authentication_failed: 'Authentication failed.'
-      need_force_update: 'Need update.'
+      an_error_has_occurred: 'An error has occurred. error_code = %{error_code}'
+      validation_error: 'Validation error. error_code = %{error_code}'
+      not_found: 'Not found. error_code = %{error_code}'
+      permission_denied: 'Permission denied. error_code = %{error_code}'
+      authentication_failed: 'Authentication failed. error_code = %{error_code}'
+      need_force_update: 'Need update. error_code = %{error_code}'
+      too_many_requests: 'Too Many Requests. error_code = %{error_code}'
 ja:
   strings:
     moromi-error:
-      an_error_has_occurred: 'エラーが発生しました。'
-      validation_error: '不正な入力です。'
-      not_found: '見つかりませんでした。'
-      permission_denied: '権限がありません。'
-      authentication_failed: '認証に失敗しました。'
-      need_force_update: '新しいバージョンのアプリがあります。'
+      an_error_has_occurred: 'エラーが発生しました。 error_code = %{error_code}'
+      validation_error: '不正な入力です。 error_code = %{error_code}'
+      not_found: '見つかりませんでした。 error_code = %{error_code}'
+      permission_denied: '権限がありません。 error_code = %{error_code}'
+      authentication_failed: '認証に失敗しました。 error_code = %{error_code}'
+      need_force_update: '新しいバージョンのアプリがあります。 error_code = %{error_code}'
+      too_many_requests: '所定の期間内に送信されたリクエスト数が多すぎます。 error_code = %{error_code}'

data/lib/generators/moromi/error/views_generator.rb

@@ -16,7 +16,8 @@ rails g moromi:error:views [options]
         desc ''
         def copy_or_fetch #:nodoc:
           copy_html_templates
-          copy_json_templates
+          copy_jbuilder_templates
+          copy_jb_templates
         end
 
         private
@@ -28,13 +29,20 @@ rails g moromi:error:views [options]
           end
         end
 
-        def copy_json_templates
+        def copy_jbuilder_templates
           filename_pattern = File.join self.class.source_root, "*.json.jbuilder"
           Dir.glob(filename_pattern).map {|f| File.basename f}.each do |f|
             copy_file f, "app/views/moromi/error/#{f}"
           end
         end
 
+        def copy_jb_templates
+          filename_pattern = File.join self.class.source_root, "*.json.jb"
+          Dir.glob(filename_pattern).map {|f| File.basename f}.each do |f|
+            copy_file f, "app/views/moromi/error/#{f}"
+          end
+        end
+
         def template_engine
           options[:template_engine]&.to_s&.downcase || 'erb'
         end

data/lib/moromi/error/config.rb

@@ -5,7 +5,9 @@ module Moromi
 
       config_accessor :debug
       config_accessor :logger
-      config_accessor :store_url
+      config_accessor :information_builder_klass
+      config_accessor :severity_mappings
+      config_accessor :use_exception_notifier
     end
   end
 end

data/lib/moromi/error/default_information_builder.rb

@@ -0,0 +1,41 @@
+require 'moromi/error/information_buildable'
+
+module Moromi
+  module Error
+    class DefaultInformationBuilder
+      include ::Moromi::Error::InformationBuildable
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def build
+        {
+          user_id: fetch_user_id(controller),
+          url: fetch_url(controller),
+          user_agent: fetch_user_agent(controller)
+        }
+      end
+
+      private
+
+      def fetch_user_id(controller)
+        controller.respond_to?(:current_user) ? controller.current_user&.id : 0
+      rescue
+        nil
+      end
+
+      def fetch_url(controller)
+        controller.request.try(:url)
+      rescue
+        nil
+      end
+
+      def fetch_user_agent(controller)
+        controller.request.try(:user_agent)
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/moromi/error/default_logger.rb

@@ -1,15 +1,70 @@
+require 'moromi/error/loggerable'
+
 module Moromi
   module Error
     class DefaultLogger
-      include Loggerable
+      include ::Moromi::Error::Loggerable
+
+      UNKNOWN = 'unknown'.freeze
 
       def write(controller, status, title, exception, options, locals)
-        return if exception.is_a? Moromi::Error::Default
+        Moromi::Error.config.severity_mappings.each do |klass, severity|
+          if exception.is_a? klass
+            message = ([exception.message] + ::Rails.backtrace_cleaner.clean(Array(exception.backtrace).compact)).join('\n')
+            Rails.logger.add severity, message
+            return
+          end
+        end
+
+        Rails.logger.add log_severity(exception), to_ltsv(controller, exception) unless skip?(exception)
+        notify_exception(controller, exception)
+      rescue => e
+        backtrace = ::Rails.backtrace_cleaner.clean(e.backtrace).join("\n").gsub("\n", '\n')
+        Rails.logger.error "[#{self.class}#write] #{e.inspect} #{backtrace}"
+      end
+
+      private
+
+      def to_ltsv(controller, exception)
+        backtrace = (exception&.backtrace || []).compact
+        information_builder = Moromi::Error.config.information_builder_klass.new(controller)
+
+        messages = {
+          error_class: exception.class,
+          message: exception.message,
+          errors: fetch_errors(exception).compact.join("\n").gsub("\n", '\n'),
+          backtrace: ::Rails.backtrace_cleaner.clean(backtrace).join("\n").gsub("\n", '\n')
+        }
+        messages.merge!(information_builder.build)
+
+        messages.map { |k, v| "#{k}:#{v}" }.join("\t")
+      rescue
+        (exception&.backtrace || []).compact.join("\n").gsub("\n", '\n')
+      end
+
+      def notify_exception(controller, exception)
+        return unless defined? ExceptionNotifier
+        return unless Moromi::Error.config.use_exception_notifier
+
+        ExceptionNotifier.notify_exception(exception, env: controller.request.env, data: {method: controller.request.method, url: controller.request.url})
+      end
+
+      def skip?(exception)
+        return false unless exception.respond_to?(:skip_logging?)
+
+        exception.skip_logging?
+      end
+
+      def log_severity(exception)
+        return Logger::Severity::ERROR unless exception.respond_to?(:log_severity)
+
+        exception.log_severity
+      end
 
-        messages = []
-        messages << ([exception.inspect] + (exception&.backtrace || [])).compact.join("\n").gsub("\n", '\n')
+      def fetch_errors(exception)
+        return [exception.inspect] unless exception.respond_to?(:errors)
 
-        Rails.logger.error(messages.join(' '))
+        exception.errors
       end
     end
   end

data/lib/moromi/error/errors.rb

@@ -5,34 +5,66 @@ module Moromi::Error
     DEFAULT_TITLE = 'moromi-error.an_error_has_occurred'
     DEFAULT_ERRORS = ['moromi-error.an_error_has_occurred']
 
-    attr_reader :code
-    attr_reader :title
     attr_reader :errors
+    attr_reader :debug_message
+    attr_reader :log_severity
+    attr_accessor :original_exception
+    attr_accessor :detail_url
 
     # @param [Integer] code
-    # @param [String] title
+    # @param [String] error_title
     # @param [Array<String>] errors
     # @param [String] message
     # @param [String] debug_message
-    def initialize(code: nil, title: nil, errors: self.class::DEFAULT_ERRORS, message: nil, debug_message: nil)
+    # @param [String] detail_url
+    # @param [Boolean] skip_logging
+    # @param [Integer] log_severity
+    def initialize(code: nil, error_title: nil, errors: self.class::DEFAULT_ERRORS, message: nil, debug_message: nil, detail_url: nil, skip_logging: false, log_severity: Logger::Severity::ERROR)
       super(message)
-      @code = code || self.class::DEFAULT_CODE
-      @title = translate(title || self.class::DEFAULT_TITLE)
-      @errors = Array(errors).map { |error| translate(error) }
+      @code = code
+      @error_title = error_title
+      @errors = errors
       @debug_message = debug_message if Moromi::Error.config.debug
+      @detail_url = detail_url
+      @skip_logging = skip_logging
+      @log_severity = log_severity
+    end
+
+    # @param [Exception] exception
+    # @return [Moromi::Error::Default]
+    def self.make(exception)
+      return exception if exception.is_a? ::Moromi::Error::Default
+
+      new(debug_message: exception.try(:message) || '').tap do |e|
+        e.original_exception = exception
+      end
+    end
+
+    def code
+      @code || self.class::DEFAULT_CODE
+    end
+
+    def errors
+      Array(@errors).map(&method(:translate))
+    end
+
+    def error_title
+      translate(@error_title || self.class::DEFAULT_TITLE)
     end
 
     # @return [String]
     def debug_message
       return '' unless Moromi::Error.config.debug
-      @debug_message || try(:backtrace).try(:first) || ''
+
+      @debug_message || cleaned_backtrace.first || ''
     end
 
-    # @param [Exception] exception
-    # @return [Moromi::Error::Default]
-    def self.make(exception)
-      return exception if exception.is_a? Default
-      new(debug_message: exception.message)
+    def skip_logging?
+      @skip_logging
+    end
+
+    def cleaned_backtrace
+      ::Rails.backtrace_cleaner.clean(backtrace || [])
     end
 
     private
@@ -40,7 +72,11 @@ module Moromi::Error
     # @param [String] key
     # @return [String]
     def translate(key)
-      I18n.translate(key, scope: [:strings], default: key.to_s)
+      I18n.t(key, scope: [:strings], default: key.to_s) % translate_params
+    end
+
+    def translate_params
+      {error_code: code}
     end
   end
 
@@ -51,13 +87,7 @@ module Moromi::Error
     # @param [Exception] exception
     # @return [Moromi::Error::Default]
     def self.make(exception)
-      if defined?(ActiveRecord::RecordInvalid) && exception.is_a?(ActiveRecord::RecordInvalid)
-        return new(debug_message: exception.try(:backtrace), message: exception.message, errors: [exception.message])
-      end
-
-      if defined?(WeakParameters::ValidationError) && exception.is_a?(WeakParameters::ValidationError)
-        return new(debug_message: exception.message, message: exception.message)
-      end
+      return new(debug_message: 'ActiveRecord::RecordInvalid', message: exception.message, errors: [exception.message]) if exception.is_a? ActiveRecord::RecordInvalid
 
       super(exception)
     end
@@ -81,7 +111,10 @@ module Moromi::Error
   class NeedForceUpdate < Default
     DEFAULT_CODE = 10004
     DEFAULT_ERRORS = ['moromi-error.need_force_update']
+  end
 
-    attr_accessor :store_url
+  class TooManyRequests < Default
+    DEFAULT_CODE = 10005
+    DEFAULT_ERRORS = ['moromi-error.too_many_requests']
   end
 end

data/lib/moromi/error/information_buildable.rb

@@ -0,0 +1,13 @@
+module Moromi
+  module Error
+    module InformationBuildable
+      def initialize(controller)
+        raise NotImplementedError
+      end
+
+      def build
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/moromi/error/renderer.rb

@@ -5,14 +5,15 @@ module Moromi::Error
 
     ERROR_TEMPLATES = {
       default: 'moromi/error/default',
-      force_update: 'moromi/error/force_update'
     }.freeze
 
     included do
+      class_attribute :default_moromi_error_template_path
       class_attribute :default_moromi_error_renderer_options
       class_attribute :moromi_error_logger
 
-      self.default_moromi_error_renderer_options = {partial: ERROR_TEMPLATES[:default], layout: false}
+      self.default_moromi_error_template_path = ERROR_TEMPLATES[:default]
+      self.default_moromi_error_renderer_options = {layout: false}
       self.moromi_error_logger = Moromi::Error::DefaultLogger.new
     end
 
@@ -40,14 +41,26 @@ module Moromi::Error
       render_error(410, 'Gone', exception, options: options, locals: locals)
     end
 
+    def render_too_many_requests(exception: Moromi::Error::Default.new, options: nil, locals: {})
+      render_error(429, 'Too Many Requests', exception, options: options, locals: locals)
+    end
+
     def render_force_update(exception: Moromi::Error::NeedForceUpdate.new, options: nil, locals: {})
-      options = options || {partial: ERROR_TEMPLATES[:force_update], layout: false}
       render_bad_request(exception: exception, options: options, locals: locals)
     end
 
+    def render_internal_server_error(exception: Moromi::Error::Default.new, options: nil, locals: {})
+      render_error(500, 'Internal Server Error', exception, options: options, locals: locals)
+    end
+
+    def render_service_unavailable(exception: Moromi::Error::Default.new, options: nil, locals: {})
+      render_error(503, 'Service Unavailable', exception, options: options, locals: locals)
+    end
+
     private
 
-    def render_error(status, title, exception, options: nil, locals: {})
+    def render_error(status, title, exception, options: nil, template_path: nil, locals: {})
+      template_path ||= self.class::default_moromi_error_template_path
       options = options || self.class::default_moromi_error_renderer_options
       e = Moromi::Error::Default.make(exception)
 
@@ -57,13 +70,15 @@ module Moromi::Error
       locals = {status: status, title: title, exception: e}.merge(locals)
 
       render_block = -> {
-        render options.merge({locals: locals})
+        render template_path, **options, locals: locals
       }
 
       respond_to do |format|
         format.html &render_block
         format.json &render_block
       end
+    rescue ActionController::UnknownFormat
+      render status: 406, body: "Not Acceptable"
     end
   end
 end

data/lib/moromi/error/rescue.rb

@@ -4,12 +4,16 @@ module Moromi
       extend ActiveSupport::Concern
 
       included do
-        rescue_from Moromi::Error::Default, with: -> (e) { render_bad_request(exception: e) }
+        # 5xx error
+        rescue_from Moromi::Error::Default, with: -> (e) { render_internal_server_error(exception: e) }
+
+        # 4xx error
         rescue_from Moromi::Error::ValidationError, with: -> (e) { render_bad_request(exception: e) }
-        rescue_from Moromi::Error::NotFound, with: -> (e) { render_not_found(exception: e) }
-        rescue_from Moromi::Error::PermissionDenied, with: -> (e) { render_forbidden(exception: e) }
         rescue_from Moromi::Error::AuthenticationFailed, with: -> (e) { render_unauthorized(exception: e) }
-        rescue_from Moromi::Error::NeedForceUpdate, with: -> (e) { e.store_url = Moromi::Error.config.store_url; render_force_update(exception: e) }
+        rescue_from Moromi::Error::PermissionDenied, with: -> (e) { render_forbidden(exception: e) }
+        rescue_from Moromi::Error::NotFound, with: -> (e) { render_not_found(exception: e) }
+        rescue_from Moromi::Error::TooManyRequests, with: -> (e) { render_too_many_requests(exception: e) }
+        rescue_from Moromi::Error::NeedForceUpdate, with: -> (e) { render_force_update(exception: e) }
       end
     end
   end

data/lib/moromi/error/version.rb

@@ -1,5 +1,5 @@
 module Moromi
   module Error
-    VERSION = "0.2.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/moromi/error.rb

@@ -1,6 +1,6 @@
 require 'moromi/error/config'
-require 'moromi/error/loggerable'
 require 'moromi/error/default_logger'
+require 'moromi/error/default_information_builder'
 require 'moromi/error/engine'
 require 'moromi/error/errors'
 require 'moromi/error/renderer'
@@ -16,10 +16,19 @@ module Moromi
       @config
     end
 
+    def self.default_severity_mappings
+      {
+        Moromi::Error::Default => Logger::Severity::DEBUG,
+        ActionController::RoutingError => Logger::Severity::WARN
+      }
+    end
+
     configure do |config|
       config.debug = false
       config.logger = Moromi::Error::DefaultLogger.new
-      config.store_url = ''
+      config.severity_mappings = default_severity_mappings
+      config.information_builder_klass = Moromi::Error::DefaultInformationBuilder
+      config.use_exception_notifier = false
     end
   end
 end

data/moromi-error.gemspec

@@ -19,14 +19,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.3'
+  spec.required_ruby_version = '>= 2.6'
 
-  spec.add_dependency 'rails', ['>= 4.2', '< 6']
-  spec.add_dependency 'jbuilder'
+  spec.add_dependency 'rails', '>= 5.2'
 
-  spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "jbuilder"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "sprockets-rails"
 end