white_noise 1.0.0

data/lib/noise/exception_renderer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+module Noise
+  # Determines how to render exception
+  #
+  # @example
+  #   class ApplicationExceptionRenderer < ExceptionRenderer
+  #     def render(responder)
+  #       if env[Rack::PATH_INFO] =~ %r{\A/partners}
+  #         {
+  #           id: error_id,
+  #           error: message,
+  #           code: code
+  #         }
+  #       else
+  #         super
+  #       end
+  #     end
+  #
+  #     def message
+  #       if error.is_a?(PublicError)
+  #         error.message
+  #       else
+  #         'Internal Server Error'
+  #       end
+  #     end
+  #
+  #     def code
+  #       if error.is_a?(PublicError)
+  #         error.message_id
+  #       else
+  #         :internal_server_error
+  #       end
+  #     end
+  #   end
+  #
+  ExceptionRenderer = Struct.new(:env) do
+    # @param responder [ExceptionResponder]
+    # @return [String] error representation
+    def render(responder)
+      ActiveModel::SerializableResource.new(
+        Array(error),
+        each_serializer: error_serializer,
+        adapter: :json,
+        root: 'errors',
+        meta: { 'status' => responder.status_code },
+        scope: { http_status: responder.status_code, id: error_id },
+      ).as_json.to_json
+    end
+
+    def error_serializer
+      error.is_a?(PublicError) ? PublicErrorSerializer : ErrorSerializer
+    end
+
+    # @return [StandardError]
+    def error
+      env['action_dispatch.exception']
+    end
+
+    # @return [String] error identifier, UUID
+    def error_id
+      env['action_dispatch.request_id']
+    end
+  end
+end

data/lib/noise/exception_responder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'rack/utils'
+require 'uber/inheritable_attr'
+require 'action_dispatch'
+require 'action_dispatch/middleware/exception_wrapper'
+require 'active_support/core_ext/object/json'
+require 'active_model_serializers'
+
+module Noise
+  # Constructs error response (status, body)
+  class ExceptionResponder
+    class << self
+      # @param error [StandardError]
+      # @param status [Integer, Symbol] HTTP status to use for response
+      # @api private
+      #
+      def register(error, status:)
+        ActionDispatch::ExceptionWrapper.rescue_responses[error.to_s] = status
+      end
+    end
+
+    # @param env [Hash] rack env
+    # @param exception_renderer [ExceptionRenderer]
+    def initialize(env, exception_renderer = Noise.config.exception_renderer.new(env))
+      @env = env
+      @exception_renderer = exception_renderer
+    end
+
+    attr_reader :env, :exception_renderer
+    protected :env
+
+    # @return [Hash] JSON-serializable body
+    def body
+      @body ||= exception_renderer.render(self)
+    end
+
+    # @return [Hash] headers
+    def headers
+      {
+        'Content-Type' => "#{::Mime::JSON}; charset=#{ActionDispatch::Response.default_charset}",
+        'Content-Length' => body.bytesize.to_s,
+      }
+    end
+
+    # @return [Integer] HTTP status code
+    def status_code
+      status_symbol = ActionDispatch::ExceptionWrapper.rescue_responses[error.class.name]
+      # calls `status_code` from Rack::Utils
+      Rack::Utils.status_code(status_symbol)
+    end
+
+    def error
+      env['action_dispatch.exception']
+    end
+  end
+end

data/lib/noise/exceptions_app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require_relative 'exception_responder'
+
+module Noise
+  # Custom rails exception app to render all API level errors as JSON.
+  #
+  # Why it needed: in case we use default ActionController's `rescue_from`
+  # we will not be able to properly handle and render exceptions raised in middlewares (like Warden),
+  # so for processing of all possible exceptions we configure Rails' `config.exceptions_app`
+  # to use our own API-specific implementation.
+  #
+  class ExceptionsApp
+    # @param env [Hash] rack env
+    def call(env)
+      responder = build_responder(env)
+      [responder.status_code, responder.headers, [responder.body]]
+    end
+
+    private
+
+    def build_responder(env)
+      error = env['action_dispatch.exception']
+      responder_class = error.respond_to?(:responder_class) ? error.responder_class : ExceptionResponder
+      responder_class.new(env)
+    end
+  end
+end

data/lib/noise/notification.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/hash/transform_values'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash/except'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/concern'
+require 'action_dispatch/http/request'
+
+module Noise
+  # Provides detailed information about exception
+  # and request context.
+  #
+  class Notification
+    WARNING = :warning
+    INFO = :info
+    ERROR = :error
+    SEVERITIES = [WARNING, INFO, ERROR].freeze
+
+    cattr_accessor :severities, instance_writer: false
+    self.severities = Hash.new(ERROR)
+
+    cattr_accessor :extractors, instance_writer: false
+    self.extractors = HashWithIndifferentAccess.new
+
+    class << self
+      # @param error_class [Class<StandardError>, String]
+      # @param severity [Symbol] severity constant
+      def register(error_class, severity:)
+        if SEVERITIES.include?(severity)
+          severities[error_class.to_s] = severity
+        else
+          fail ArgumentError, "Wrong severity `#{severity}`, allowed: #{SEVERITIES}"
+        end
+      end
+
+      # Extract info from request and it to Bugsnag notification
+      # @param key [Symbol, String] name of the parameter
+      # @param extractor [#call]
+      # @return [void]
+      #
+      #   class ApiClientExtractor
+      #     def call(env)
+      #       env.slice(:client_version, :client_id)
+      #     end
+      #   end
+      #   Notification.extract(:api_client, ApiClientExtractor)
+      #
+      def extract(key, extractor)
+        extractors[key] = extractor
+      end
+    end
+
+    # @param error [StandardError]
+    # @param env [Hash] rack env
+    #   @see http://www.rubydoc.info/github/rack/rack/master/file/SPEC
+    #
+    def initialize(error, env)
+      @error = error
+      @env = env
+    end
+
+    # @return [{String, Any}]
+    def to_hash
+      extractors.except('user').transform_values do |extractor|
+        extractor.new.call(@env)
+      end
+    end
+
+    # @return [String] Error severity
+    def severity
+      severities[@error.class.name].to_s
+    end
+
+    # @return [Hash] User info
+    def user_info
+      user =
+        if extractors.key?('user')
+          extractors['user'].new.call(@env)
+        else
+          {}
+        end
+      fail '`name` key is reserved to identify error itself' if user.key?('name')
+      user.merge('name' => request.uuid)
+    end
+
+    private
+
+    def request
+      @request ||= ActionDispatch::Request.new(@env)
+    end
+  end
+end

data/lib/noise/public_error.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require 'noise/notification'
+require 'noise/exception_responder'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+require 'i18n'
+
+#
+module Noise
+  # Base class for all api level errors
+  #
+  class PublicError < StandardError
+    attr_reader :message_id
+    attr_reader :options
+
+    # @overload new(message_id, message)
+    #   Instantiate error with given message_id and message
+    #   @param message_id [Symbol]
+    #   @param message_or_options [String]
+    # @overload new(message_id, options)
+    #   Instantiate error with given message_id and options.
+    #   Options would be passed to I18n key
+    #   @param message_id [Symbol]
+    #   @param message_or_options [Hash{Symbol => any}]
+    #   @example
+    #     Given the following I18n key exists:
+    #       noise:
+    #         public_error:
+    #           unknown_fields: "Server does not know how to recognize these fields: %{fields}"
+    #
+    #     To render error with this message:
+    #       PublicError.new(:unknown_fields, fields: 'nickname, phone')
+    #
+    def initialize(message_id, message_or_options = nil)
+      @message_id = message_id.to_sym
+      case message_or_options
+      when Hash
+        @options = message_or_options
+        @message = nil
+      else
+        @options = {}
+        @message = message_or_options
+      end
+    end
+
+    # @return [String]
+    def message
+      @message.presence || I18n.t("noise.#{self.class.name.demodulize.underscore}.#{@message_id}", @options)
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class}: #{message}>"
+    end
+
+    # @return [ExceptionResponder]
+    # @api private
+    def responder_class
+      ExceptionResponder
+    end
+
+    class << self
+      # @param status [Symbol, Integer]
+      #   @see http://apidock.com/rails/ActionController/Base/render#254-List-of-status-codes-and-their-symbols
+      # @param severity [Symbol, Integer]
+      #   @see `Noise::Notification::SEVERITIES`
+      #
+      # @example
+      #   GoneError.register_as(:gone, :info)
+      #
+      def register_as(status, severity:)
+        Noise::ExceptionResponder.register(name, status: status)
+        Noise::Notification.register(name, severity: severity)
+      end
+    end
+  end
+
+  # 400
+  BadRequestError = Class.new(PublicError)
+  BadRequestError.register_as :bad_request, severity: :info
+
+  # 401
+  UnauthorizedError = Class.new(PublicError)
+  UnauthorizedError.register_as :unauthorized, severity: :warning
+
+  # 403
+  ForbiddenError = Class.new(PublicError)
+  ForbiddenError.register_as :forbidden, severity: :warning
+
+  # 404
+  class NotFoundError < PublicError
+    def initialize(message_id = 'not_found', message = nil)
+      super
+    end
+  end
+  NotFoundError.register_as :not_found, severity: :info
+
+  # 410
+  GoneError = Class.new(PublicError)
+  GoneError.register_as :gone, severity: :info
+
+  # 415
+  class UnsupportedMediaTypeError < PublicError
+    def initialize(message_id = 'unsupported_media_type', message = nil)
+      super
+    end
+  end
+  UnsupportedMediaTypeError.register_as :unsupported_media_type, severity: :info
+
+  # 422
+  class UnprocessableEntityError < PublicError
+    def initialize(message_id = :unprocessable_entity, message = nil)
+      super
+    end
+  end
+  UnprocessableEntityError.register_as :unprocessable_entity, severity: :info
+
+  # 503
+  ServiceUnavailableError = Class.new(PublicError)
+  ServiceUnavailableError.register_as :service_unavailable, severity: :warning
+
+  # 504
+  GatewayTimeoutError = Class.new(PublicError)
+  GatewayTimeoutError.register_as :gateway_timeout, severity: :warning
+end

data/lib/noise/public_error_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Noise
+  # Errors api representation.
+  # Serializes api level errors to general errors format.
+  #
+  class PublicErrorSerializer < ErrorSerializer
+    def code
+      object.message_id
+    end
+
+    def title
+      object.message
+    end
+  end
+end

data/lib/noise/railtie.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'rails/railtie'
+require 'noise'
+
+module Noise
+  # Rails initializers
+  class Railtie < Rails::Railtie
+    initializer 'noise.exceptions_app' do
+      require 'noise/exceptions_app'
+
+      Rails.application.config.exceptions_app = Noise::ExceptionsApp.new
+    end
+
+    initializer 'noise.bugsnag' do
+      if Noise.config.bugsnag_enabled
+        require 'noise/bugsnag_middleware'
+
+        Bugsnag.configure do |config|
+          config.middleware.use Noise::BugsnagMiddleware
+        end
+      end
+    end
+  end
+end

data/lib/noise/rate_limit_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'noise/public_error'
+require 'noise/rate_limit_error_responder'
+
+module Noise
+  # Rate limit error.
+  #
+  class RateLimitError < PublicError
+    attr_reader :retry_after
+
+    # @param message_id [Symbol]
+    # @param [String] retry_after
+    #
+    def initialize(message_id, retry_after:)
+      super(message_id)
+
+      @retry_after = retry_after
+    end
+
+    def responder_class
+      RateLimitErrorResponder
+    end
+  end
+end
+
+Noise::RateLimitError.register_as :too_many_requests, severity: :info

data/lib/noise/rate_limit_error_responder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'noise/exception_responder'
+
+module Noise
+  # Special error responder with Retry-After header render support.
+  #
+  class RateLimitErrorResponder < ExceptionResponder
+    # @return [Hash]
+    def headers
+      super.merge(
+        'Retry-After' => error.retry_after.to_s,
+      )
+    end
+  end
+end

data/lib/noise/version.rb

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

data/lib/noise.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'noise/version'
+require 'noise/public_error'
+require 'noise/rate_limit_error'
+require 'active_support/configurable'
+
+#
+module Noise
+  include ActiveSupport::Configurable
+  extend ActiveSupport::Autoload
+
+  autoload :ErrorSerializer
+  autoload :ExceptionRenderer
+  autoload :PublicErrorSerializer
+
+  config.bugsnag_enabled = true
+  config.bugsnag_organization = nil
+  config.bugsnag_project = nil
+  config.exception_renderer = ExceptionRenderer
+end

data/lib/white_noise.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require_relative 'noise'

data/white_noise.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'noise/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'white_noise'
+  spec.version       = Noise::VERSION
+  spec.authors       = ['Tema Bolshakov']
+  spec.email         = ['abolshakov@spbtv.com']
+  spec.license       = 'Apache-2.0'
+  spec.summary       = 'Defines middleware which renders exceptions and notifies Bugsnag.'
+  spec.homepage      = 'https://github.com/SPBTV/white_noise'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'i18n', '~> 0.7.0'
+  spec.add_runtime_dependency 'activesupport', '~> 4.2'
+  spec.add_runtime_dependency 'actionpack', '~> 4.2'
+  spec.add_runtime_dependency 'active_model_serializers', '0.10.0.rc4'
+  spec.add_runtime_dependency 'uber', '~> 0.0.15'
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4'
+  spec.add_development_dependency 'spbtv_code_style', '1.4.1'
+  spec.add_development_dependency 'bugsnag', '~> 6.6.3'
+  spec.add_development_dependency 'addressable', '~> 2.3'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.2.3'
+end