jsonapi-resources 0.5.8 → 0.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61e3e8cacf54569eb7d57771d08cdd4861a84a22
-  data.tar.gz: 25ccc4dc6996b991af26ebc7598129615ee14b4c
+  metadata.gz: f421adb3d1c9d4ac14ec14de18bffb8e03233b8f
+  data.tar.gz: 738efbc31c5bd1d1d1a7dc1c3bd83c7f9163e6ae
 SHA512:
-  metadata.gz: 20e94f28d19e31142b2f80c562356a87d17f6d49df68918b4ff9be66a4528b1f734b86a0f98b25fafa566d4c2e3565d08f9cca6ec34878c32b8e40d3e580f029
-  data.tar.gz: 52bcc55a0d1200315129584fb978c75cbcd67bdcebb546cb8a62d137cc4d21f95cf9b1b938303a2dbbe603bb785f265d4f3d2b0b7d6c25746a717de40d5629fe
+  metadata.gz: 16c6f58ddc71ba0f97489b7ff725ff41905f43b1329a23b60004f250567180ff385d87d822dd4c4197ec13b9f7bfad6ee20062335dd558328ce6e78e5bb182c0
+  data.tar.gz: f1263437a5904619e8f11ff34f6bf7f701ad9f48bb1b272a6790ec45fcffb361121cfe5f0d66f8332f8283aa16b2b7e68e003895919f4f5e7e1998315e1512b0

data/README.md

@@ -28,6 +28,7 @@ backed by ActiveRecord models or by custom objects.
   * [Controllers] (#controllers)
     * [Namespaces] (#namespaces)
     * [Error Codes] (#error-codes)
+    * [Handling Exceptions] (#handling-exceptions)
   * [Serializer] (#serializer)
 * [Configuration] (#configuration)
 * [Contributing] (#contributing)
@@ -988,6 +989,31 @@ JSONAPI.configure do |config|
 end
 ```
 
+
+#### Handling Exceptions
+
+By default, all exceptions raised downstream from a resource controller will be caught, logged, and a ```500 Internal Server Error``` will be rendered. Exceptions can be whitelisted in the config to pass through the handler and be caught manually, or you can pass a callback from a resource controller to insert logic into the rescue block without interrupting the control flow. This can be particularly useful for additional logging or monitoring without the added work of rendering responses.
+
+Pass a block, refer to controller class methods, or both. Note that methods must be defined as class methods on a controller and accept one parameter, which is passed the exception object that was rescued. 
+
+```ruby
+  class ApplicationController < JSONAPI::ResourceController
+
+    on_server_error :first_callback 
+
+    #or
+
+    # on_server_error do |error|
+      #do things
+    #end
+
+    def self.first_callback(error)
+      #env["airbrake.error_id"] = notify_airbrake(error)
+    end
+  end
+
+```
+
 ### Serializer
 
 The `ResourceSerializer` can be used to serialize a resource into JSON API compliant JSON. `ResourceSerializer` must be

data/lib/jsonapi/active_record_operations_processor.rb

@@ -15,26 +15,20 @@ class ActiveRecordOperationsProcessor < JSONAPI::OperationsProcessor
     fail ActiveRecord::Rollback if @transactional
   end
 
+  # Catch errors that should be handled before JSONAPI::Exceptions::Error
+  # and other unprocessed exceptions
   def process_operation(operation)
-    operation.apply
-  rescue ActiveRecord::DeleteRestrictionError => e
-    record_locked_error = JSONAPI::Exceptions::RecordLocked.new(e.message)
-    return JSONAPI::ErrorsOperationResult.new(record_locked_error.errors[0].code, record_locked_error.errors)
+    with_default_handling do 
+      begin
+        operation.apply
+      rescue ActiveRecord::DeleteRestrictionError => e
+        record_locked_error = JSONAPI::Exceptions::RecordLocked.new(e.message)
+        return JSONAPI::ErrorsOperationResult.new(record_locked_error.errors[0].code, record_locked_error.errors)
 
-  rescue ActiveRecord::RecordNotFound
-    record_not_found = JSONAPI::Exceptions::RecordNotFound.new(operation.associated_key)
-    return JSONAPI::ErrorsOperationResult.new(record_not_found.errors[0].code, record_not_found.errors)
-
-  rescue JSONAPI::Exceptions::Error => e
-    raise e
-
-  rescue => e
-    if JSONAPI.configuration.exception_class_whitelist.any? { |k| e.class.ancestors.include?(k) }
-      raise e
-    else
-      internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
-      Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
-      return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
-    end
+      rescue ActiveRecord::RecordNotFound
+        record_not_found = JSONAPI::Exceptions::RecordNotFound.new(operation.associated_key)
+        return JSONAPI::ErrorsOperationResult.new(record_not_found.errors[0].code, record_not_found.errors)
+      end
+    end  
   end
 end

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -182,5 +182,37 @@ module JSONAPI
         # :nocov:
       end
     end
+
+    def add_error_callbacks(callbacks)
+      @request.server_error_callbacks = callbacks || []
+    end
+
+    # Pass in a methods or a block to be run when an exception is 
+    # caught that is not a JSONAPI::Exceptions::Error
+    # Useful for additional logging or notification configuration that 
+    # would normally depend on rails catching and rendering an exception.
+    # Ignores whitelist exceptions from config
+
+    class_methods do 
+      def on_server_error(*args, &callback_block)
+        callbacks = []
+
+        if callback_block 
+          callbacks << callback_block
+        end
+
+        method_callbacks = args.map do |method|
+          ->(error) do 
+            if self.respond_to? method
+              send(method, error)
+            else
+              Rails.logger.warn("#{method} not defined on #{self}, skipping error callback")
+            end
+          end
+        end.compact
+        callbacks += method_callbacks
+        append_before_filter { add_error_callbacks(callbacks) }
+      end
+    end
   end
 end

data/lib/jsonapi/operations_processor.rb

@@ -77,25 +77,42 @@ module JSONAPI
     def rollback
     end
 
+    # If overriding in child operation processors, call operation.apply and 
+    # catch errors that should be handled before JSONAPI::Exceptions::Error
+    # and other unprocessed exceptions
     def process_operation(operation)
-      operation.apply
+      with_default_handling do 
+        operation.apply
+      end        
+    end
 
+    def with_default_handling(&block)
+      yield
     rescue JSONAPI::Exceptions::Error => e
-      # :nocov:
       raise e
-      # :nocov:
 
     rescue => e
-      # :nocov:
-      if JSONAPI.configuration.exception_class_whitelist.include?(e.class)
+      if JSONAPI.configuration.exception_class_whitelist.any? { |k| e.class.ancestors.include?(k) }
         raise e
       else
+        @request.server_error_callbacks.each { |callback| safe_run_callback(callback, e) }
+
         internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
         Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
         return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
       end
-      # :nocov:
     end
+
+    def safe_run_callback(callback, error)
+      begin 
+        callback.call(error)
+      rescue => e
+        Rails.logger.error { "Error in error handling callback: #{e.message} #{e.backtrace.join("\n")}" }
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
+      end
+    end
+
   end
 end
 

data/lib/jsonapi/request.rb

@@ -5,7 +5,7 @@ module JSONAPI
   class Request
     attr_accessor :fields, :include, :filters, :sort_criteria, :errors, :operations,
                   :resource_klass, :context, :paginator, :source_klass, :source_id,
-                  :include_directives, :params, :warnings
+                  :include_directives, :params, :warnings, :server_error_callbacks
 
     def initialize(params = nil, options = {})
       @params = params
@@ -22,6 +22,7 @@ module JSONAPI
       @include_directives = nil
       @paginator = nil
       @id = nil
+      @server_error_callbacks = []
 
       setup_action(@params)
     end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.5.8'
+    VERSION = '0.5.9'
   end
 end

data/test/controllers/controller_test.rb

@@ -31,6 +31,57 @@ class PostsControllerTest < ActionController::TestCase
     JSONAPI.configuration = original_config
   end
 
+  def test_on_server_error_block_callback_with_exception
+    original_config = JSONAPI.configuration.dup
+    JSONAPI.configuration.operations_processor = :error_raising
+    JSONAPI.configuration.exception_class_whitelist = []
+
+    @controller.class.instance_variable_set(:@callback_message, "none")
+    @controller.class.on_server_error do
+      @controller.class.instance_variable_set(:@callback_message, "Sent from block")
+    end
+    
+    get :index
+    assert_equal @controller.class.instance_variable_get(:@callback_message), "Sent from block"
+
+    # test that it renders the default server error response
+    assert_equal "Internal Server Error", json_response['errors'][0]['title']
+    assert_equal "Internal Server Error", json_response['errors'][0]['detail']
+  ensure
+    JSONAPI.configuration = original_config
+  end
+
+  def test_on_server_error_method_callback_with_exception
+    original_config = JSONAPI.configuration.dup
+    JSONAPI.configuration.operations_processor = :error_raising
+    JSONAPI.configuration.exception_class_whitelist = [] 
+
+    #ignores methods that don't exist
+    @controller.class.on_server_error :set_callback_message, :a_bogus_method
+    @controller.class.instance_variable_set(:@callback_message, "none")
+
+    get :index
+    assert_equal @controller.class.instance_variable_get(:@callback_message), "Sent from method"
+
+    # test that it renders the default server error response
+    assert_equal "Internal Server Error", json_response['errors'][0]['title']
+  ensure
+    JSONAPI.configuration = original_config
+  end
+
+  def test_on_server_error_callback_without_exception
+    
+    callback = Proc.new { @controller.class.instance_variable_set(:@callback_message, "Sent from block") }
+    @controller.class.on_server_error callback
+    @controller.class.instance_variable_set(:@callback_message, "none")
+
+    get :index
+    assert_equal @controller.class.instance_variable_get(:@callback_message), "none"
+
+    # test that it does not render error
+    assert json_response.key?('data')
+  end
+
   def test_index_filter_with_empty_result
     get :index, {filter: {title: 'post that does not exist'}}
     assert_response :success

data/test/fixtures/active_record.rb

@@ -478,6 +478,11 @@ class PostsController < ActionController::Base
   rescue_from PostsController::SpecialError do
     head :forbidden
   end
+
+  #called by test_on_server_error
+  def self.set_callback_message(error)
+    @callback_message = "Sent from method"
+  end
 end
 
 class CommentsController < JSONAPI::ResourceController

data/test/unit/operation/operations_processor_test.rb

@@ -503,4 +503,26 @@ class OperationsProcessorTest < Minitest::Test
     assert_equal(operation_results.results.size, 1)
     assert operation_results.has_errors?
   end
+
+  def test_safe_run_callback_pass
+    op = JSONAPI::OperationsProcessor.new
+    error = StandardError.new
+
+    check = false
+    callback = ->(error) { check = true}
+
+    op.send(:safe_run_callback, callback, error)
+    assert check
+  end
+
+  def test_safe_run_callback_catch_fail
+    op = JSONAPI::OperationsProcessor.new
+    error = StandardError.new
+
+    callback = ->(error) { nil.explosions}
+    result = op.send(:safe_run_callback, callback, error) 
+
+    assert_instance_of(JSONAPI::ErrorsOperationResult, result)
+    assert_equal(result.code, 500)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.5.9
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-02 00:00:00.000000000 Z
+date: 2015-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler