hoodoo 1.2.3 → 1.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDRkMTlhM2I2NjQyNWE2OTQxZDA3MjdiMjQ2MjgzMzVkYjhkMWEwOQ==
+    N2VjMWU3NjI1YmZmODQ1NDQ3OTYxMTg1MTk3YzRhNmQzM2U3YzZhNw==
   data.tar.gz: !binary |-
-    NjMxZTIwOTI0OGFiMzgxMDEyYjRmY2JjM2MwODI3MDJmOTNjMjgyNQ==
+    NzFkZjIyZTk0YmUzNTVhY2IxZWMxMThiMWU0ZmZiMzhmOGNkYjk5Yw==
 SHA512:
   metadata.gz: !binary |-
-    YzdiYTY3MTIyY2VkMWZjZjI5N2RmYjBkY2M1NTYyZWVjZjFiOWM0NDU4YjVk
-    MGM4MGI1MWFlYzNhNjg0MzNlYmU0YzYwMzZhMDViNDgwYmVjN2ExZWY3MjJi
-    NGQ0NDRmOThhZjE4MWQwNmEyODk5NmYxNmE0NTkzMmY2YTliMjE=
+    ZjViZWUyYzM2NmY3NmNjZjFlNTQ1ZjkyZWY1ZGE1N2VmNmQ0MDA3N2ExNmNj
+    M2RlNDZjYTlhOTU5NjM0NWU4NjQ5MjhhODVkMTk2YjE0MjM0NTM4ZDgzYjI3
+    ODRiYTVkNzE2OTQxY2IzYjE4NzA1ZGJkNGUxZDUzYmZjMGViNDk=
   data.tar.gz: !binary |-
-    NGM2NmNlMmQ2ZGYwZmVhMmEwZWMyYjU1NjJmZTBhYTU1M2UzNzMyMjRlZjRj
-    ZTAzNzM5MDI0MmRlMmU4OWU4MzBlZWUxNTRiMGU4MzE4YWI4YTE3M2M1MGMy
-    ZjI1MWY1YWM5NmQwNWYyYWZhNTk0MTA1OGU4NWVkN2Y4YTUzNDE=
+    ZGI3OTZlM2QzYmFhNGVjZGIzYTJlNGM0NDZmZDYwN2MxOTNiODE1ZWEwYjEw
+    MDRmMzQxMWMwNGM1ZDJjM2RlMDk0NzZiMzg5MTBiYTg1MDJmMWFlMjFkNzQw
+    MGU5NGI3ZGIyYmI5OWExZjUxNDZlODljZmY4YTMxYmQzN2IzZGE=

data/lib/hoodoo/services/middleware/exception_reporting/base_reporter.rb

@@ -84,6 +84,30 @@ module Hoodoo; module Services
           raise( 'Subclasses must implement #report' )
         end
 
+        # Similar to #report, with the same caveats; but has more information
+        # available.
+        #
+        # Subclasses report an exception for errors that occur within a fully
+        # handled Rack request context, with a high level processed Hoodoo
+        # representation available.
+        #
+        # Through the protected #user_data_for method, subclasses can, if the
+        # exception reporting backend supports it, include detailed request
+        # information with their contextual exception reports.
+        #
+        # Implementation is optional. If not available, the system falls back
+        # to the less detailed #report method. If called, all parameters must
+        # be provided; none are optional.
+        #
+        # +e+::       Exception (or subclass) instance to be reported.
+        #
+        # +context+:: Hoodoo::Services::Context instance describing an
+        #             in-flight request/response cycle.
+        #
+        def contextual_report( e, context )
+          raise( 'Subclasses may implement #contextual_report' )
+        end
+
         # Subclasses *MUST* *NOT* override this method, which is part of the
         # base class implementation and implements
         # Hoodoo::Communicators::Slow#communicate. It calls through to the
@@ -95,7 +119,66 @@ module Hoodoo; module Services
         #            instance.
         #
         def communicate( object )
-          self.report( object.exception, object.rack_env )
+
+          env = object.rack_env || ( object.context.owning_interaction.rack_request.env rescue nil )
+
+          # The 'instance_methods( false )' call pulls only instance methods
+          # strictly defined in 'self' instance, not in any superclasses.
+          # Thus we don't see the base implementation of 'contextual_report'
+          # in this source file; only an overriding implementation in a real
+          # reporter subclass.
+          #
+          # http://ruby-doc.org/core-2.1.8/Module.html#method-i-instance_methods
+          #
+          subclass_methods = self.class.instance_methods( false )
+
+          if object.context && subclass_methods.include?( :contextual_report )
+            self.contextual_report( object.exception, object.context )
+          else
+            self.report( object.exception, env )
+          end
+        end
+
+        protected
+
+        # When passed a request context, extracts information that can be given
+        # as "user data" (or similar) to a exception reporting endpoint, if it
+        # supports such a concept.
+        #
+        # +context+:: Hoodoo::Services::Context instance describing an
+        #             in-flight request/response cycle.
+        #
+        def user_data_for( context )
+          begin
+            hash = {
+              :interaction_id =>   context.owning_interaction.interaction_id,
+              :action         => ( context.owning_interaction.requested_action          || '(unknown)' ).to_s,
+              :resource       => ( context.owning_interaction.target_interface.resource || '(unknown)' ).to_s,
+              :version        =>   context.owning_interaction.target_interface.version,
+              :request        => {
+                :locale              => context.request.locale,
+                :uri_path_components => context.request.uri_path_components,
+                :uri_path_extension  => context.request.uri_path_extension,
+                :embeds              => context.request.embeds,
+                :references          => context.request.references,
+                :headers             => context.request.headers,
+                :list                => {
+                  :offset      => context.request.list.offset,
+                  :limit       => context.request.list.limit,
+                  :sort_data   => context.request.list.sort_data,
+                  :search_data => context.request.list.search_data,
+                  :filter_data => context.request.list.filter_data
+                }
+              }
+            }
+
+            hash[ :session ] = context.session.to_h unless context.session.nil?
+            return hash
+
+          rescue
+            return nil
+
+          end
         end
       end
 

data/lib/hoodoo/services/middleware/exception_reporting/exception_reporting.rb

@@ -75,6 +75,21 @@ module Hoodoo; module Services
         @@reporter_pool.communicate( payload )
       end
 
+      # Call all added exception reporters (see ::add) to report an exception
+      # based on the context of an in-flight request/response cycle. Reporters
+      # need to support the contextual reporting mechanism. If any do not, the
+      # simpler ::report mechanism is used as a fallback.
+      #
+      # +exception+:: Exception or Exception subclass instance to report.
+      #
+      # +context+::   Hoodoo::Services::Context instance describing the
+      #               in-flight request/response cycle.
+      #
+      def self.contextual_report( exception, context )
+        payload = Payload.new( exception: exception, context: context )
+        @@reporter_pool.communicate( payload )
+      end
+
       # Wait for all executing reporter threads to catch up before continuing.
       #
       # +timeout+:: Optional timeout wait delay *for* *each* *thread*. Default
@@ -99,14 +114,21 @@ module Hoodoo; module Services
         #
         attr_accessor :rack_env
 
+        # A Hoodoo::Services::Context instance describing the in-flight
+        # request/response cycle, if there is one. May be +nil+.
+        #
+        attr_accessor :context
+
         # Initialize this instance with named parameters:
         #
         # +exception+:: Exception (or Exception subclass) instance. Mandatory.
         # +rack_env+::  Rack environment hash. Optional.
+        # +context+::   Hoodoo::Services::Context instance. Optional.
         #
-        def initialize( exception:, rack_env: nil )
+        def initialize( exception:, rack_env: nil, context: nil )
           @exception = exception
           @rack_env  = rack_env
+          @context   = context
         end
       end
     end

data/lib/hoodoo/services/middleware/exception_reporting/reporters/airbrake_reporter.rb

@@ -48,13 +48,36 @@ module Hoodoo; module Services
         #
         # +e+::   Exception (or subclass) instance to be reported.
         #
-        # +env+:: Optional Rack environment hash for the inbound request, for
-        #         exception reports made in the context of Rack request
+        # +env+:: Optional Rack environment hash for the inbound request,
+        #         for exception reports made in the context of Rack request
         #         handling. In the case of Airbrake, the call may just hang
         #         unless a Rack environment is provided.
         #
-        def report( e, env = nil )
-          Airbrake.notify_or_ignore( e, :rack_env => env )
+        def report( e, env )
+          opts = { :backtrace => Kernel.caller() }
+          opts[ :rack_env ] = env unless env.nil?
+
+          Airbrake.notify_or_ignore( e, opts )
+        end
+
+        # Report an exception for errors that occur within a fully handled Rack
+        # request context, with a high level processed Hoodoo representation
+        # available.
+        #
+        # +e+::       Exception (or subclass) instance to be reported.
+        #
+        # +context+:: Hoodoo::Services::Context instance describing an
+        #             in-flight request/response cycle.
+        #
+        def contextual_report( e, context )
+          opts = {
+            :rack_env         => context.owning_interaction.rack_request.env,
+            :backtrace        => Kernel.caller(),
+            :environment_name => Hoodoo::Services::Middleware.environment,
+            :session          => user_data_for( context ) || 'unknown'
+          }
+
+          Airbrake.notify_or_ignore( e, opts )
         end
       end
 

data/lib/hoodoo/services/middleware/exception_reporting/reporters/raygun_reporter.rb

@@ -48,13 +48,29 @@ module Hoodoo; module Services
         #
         # +e+::   Exception (or subclass) instance to be reported.
         #
-        # +env+:: Optional Rack environment hash for the inbound request, for
-        #         exception reports made in the context of Rack request
+        # +env+:: Optional Rack environment hash for the inbound request,
+        #         for exception reports made in the context of Rack request
         #         handling.
         #
         def report( e, env = nil )
           Raygun.track_exception( e, env )
         end
+
+        # Report an exception for errors that occur within a fully handled Rack
+        # request context, with a high level processed Hoodoo representation
+        # available.
+        #
+        # +e+::       Exception (or subclass) instance to be reported.
+        #
+        # +context+:: Hoodoo::Services::Context instance describing an
+        #             in-flight request/response cycle.
+        #
+        def contextual_report( e, context )
+          hash = context.owning_interaction.rack_request.env rescue {}
+          hash = hash.merge( :custom_data => user_data_for( context ) || { 'user_data' => 'unknown' } )
+
+          Raygun.track_exception( e, hash )
+        end
       end
 
     end

data/lib/hoodoo/services/middleware/middleware.rb

@@ -498,8 +498,12 @@ module Hoodoo; module Services
 
       rescue => exception
         begin
+          if interaction && interaction.context
+            ExceptionReporting.contextual_report( exception, interaction.context )
+          else
+            ExceptionReporting.report( exception, env )
+          end
 
-          ExceptionReporting.report( exception, env )
           record_exception( interaction, exception )
 
           return respond_for( interaction )

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.2.3'
+  VERSION = '1.3.0'
 
 end

data/spec/services/middleware/exception_reporting/base_reporter_spec.rb

@@ -4,6 +4,8 @@ describe Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter do
   class TestERBase < described_class
   end
 
+  # The #communicate method is checked via exception_reporting_spec.rb.
+
   it 'is a singleton' do
     expect( TestERBase.instance ).to be_a( TestERBase )
   end
@@ -11,6 +13,97 @@ describe Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter do
   it 'provides a reporting example' do
     expect {
       TestERBase.instance.report( RuntimeError.new )
-    }.to raise_exception( RuntimeError )
+    }.to raise_exception( RuntimeError, 'Subclasses must implement #report' )
+  end
+
+  it 'provides a contextual reporting example' do
+    expect {
+      TestERBase.instance.contextual_report( RuntimeError.new, nil )
+    }.to raise_exception( RuntimeError, 'Subclasses may implement #contextual_report' )
+  end
+
+  context '#user_data_for' do
+
+    class UserDataImplementation < Hoodoo::Services::Implementation
+    end
+
+    class UserDataInterface < Hoodoo::Services::Interface
+      interface :UserData do
+        version 2
+        endpoint :user_data, UserDataImplementation
+      end
+    end
+
+    before :each do
+
+      # This requires a great big heap of setup to avoid lots of mocking
+      # and keep the test reasonably meaningful.
+
+      session = Hoodoo::Services::Middleware.test_session()
+      request = Hoodoo::Services::Request.new
+
+      request.locale              = 'en-nz'
+      request.uri_path_components = [ 'path', 'subpath' ]
+      request.uri_path_extension  = 'tar.gz'
+      request.embeds              = [ 'e1', 'e2' ]
+      request.references          = [ 'r1', 'r2' ]
+      request.headers             = { 'HTTP_X_EXAMPLE' => '42' }
+      request.list.offset         = 0
+      request.list.limit          = 50
+      request.list.sort_data      = { 'created_at' => 'desc' }
+      request.list.search_data    = { 'example'    => '42'   }
+      request.list.filter_data    = { 'unexample'  => '24'   }
+
+      @mock_iid          = Hoodoo::UUID.generate()
+      mock_env           = { 'HTTP_X_INTERACTION_ID' => @mock_iid }
+      owning_interaction = Hoodoo::Services::Middleware::Interaction.new(
+        mock_env,
+        nil,
+        session
+      )
+
+      owning_interaction.target_interface = UserDataInterface
+
+      @context = Hoodoo::Services::Context.new(
+        session,
+        request,
+        nil,
+        owning_interaction
+      )
+    end
+
+    it 'works' do
+      hash = TestERBase.instance.send( :user_data_for, @context )
+      expect( hash ).to eq(
+        {
+          :interaction_id => @mock_iid,
+          :action         => '(unknown)',
+          :resource       => 'UserData',
+          :version        => 2,
+          :request        => {
+            :locale              => 'en-nz',
+            :uri_path_components => [ 'path', 'subpath' ],
+            :uri_path_extension  => 'tar.gz',
+            :embeds              => [ 'e1', 'e2' ],
+            :references          => [ 'r1', 'r2' ],
+            :headers             => { 'HTTP_X_EXAMPLE' => '42' },
+            :list                => {
+              :offset      => 0,
+              :limit       => 50,
+              :sort_data   => { 'created_at' => 'desc' },
+              :search_data => { 'example'    => '42'   },
+              :filter_data => { 'unexample'  => '24'   }
+            }
+          },
+          :session => Hoodoo::Services::Middleware.test_session().to_h()
+        }
+      )
+    end
+
+    it 'returns "nil" for bad contexts' do
+      @context.owning_interaction.target_interface = nil
+      hash = TestERBase.instance.send( :user_data_for, @context )
+      expect( hash ).to be_nil
+    end
   end
 end

data/spec/services/middleware/exception_reporting/exception_reporting_spec.rb

@@ -22,11 +22,22 @@ describe Hoodoo::Services::Middleware::ExceptionReporting do
     end
   end
 
+  class TestReporterD < Hoodoo::Services::Middleware::ExceptionReporting::BaseReporter
+    def report( e, env = nil )
+      expectable_hook_d1( e, env )
+    end
+
+    def contextual_report( e, context )
+      expectable_hook_d2( e, context )
+    end
+  end
+
   after :each do
     Hoodoo::Services::Middleware::ExceptionReporting.wait()
     Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterA )
     Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterB )
     Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterC )
+    Hoodoo::Services::Middleware::ExceptionReporting.remove( TestReporterD )
   end
 
   it 'lets me add and remove handlers' do
@@ -89,4 +100,63 @@ describe Hoodoo::Services::Middleware::ExceptionReporting do
     expect( TestReporterA.instance ).to receive( :expectable_hook_a ).once.with( ex, ha )
     Hoodoo::Services::Middleware::ExceptionReporting.report( ex, ha )
   end
+
+  context 'with contextual reporting' do
+    before :each do
+      Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterD )
+    end
+
+    it 'supports normal behaviour' do
+      ex = RuntimeError.new( 'D' )
+      ha = { :foo => :bar }
+
+      expect( TestReporterD.instance ).to receive( :expectable_hook_d1 ).once.with( ex, ha )
+      Hoodoo::Services::Middleware::ExceptionReporting.report( ex, ha )
+    end
+
+    it 'supports contextual behaviour' do
+      ex = RuntimeError.new( 'D' )
+      co = { :bar => :baz }
+
+      expect( TestReporterD.instance ).to receive( :expectable_hook_d2 ).once.with( ex, co )
+      Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+    end
+
+    context 'falling back to normal' do
+      before :each do
+        Hoodoo::Services::Middleware::ExceptionReporting.add( TestReporterA )
+      end
+
+      # When falling back, it should extract the Rack env (mocked here) from
+      # the context and pass that to the normal reporter.
+      #
+      it 'extracts the Rack "env"' do
+        ex = RuntimeError.new( 'D' )
+        ha = { :foo => :bar }
+        co = OpenStruct.new
+
+        co.owning_interaction = OpenStruct.new
+        co.owning_interaction.rack_request = OpenStruct.new
+        co.owning_interaction.rack_request.env = ha
+
+        expect( TestReporterD.instance ).to receive( :expectable_hook_d2 ).once.with( ex, co )
+        expect( TestReporterA.instance ).to receive( :expectable_hook_a  ).once.with( ex, ha )
+
+        Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+      end
+
+      # If it can't extract the Rack request from the context when falling back,
+      # the normal reporter should just be called with a "nil" second parameter.
+      #
+      it 'recovers from bad contexts' do
+        ex = RuntimeError.new( 'D' )
+        co = { :bar => :baz }
+
+        expect( TestReporterD.instance ).to receive( :expectable_hook_d2 ).once.with( ex, co  )
+        expect( TestReporterA.instance ).to receive( :expectable_hook_a  ).once.with( ex, nil )
+
+        Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+      end
+    end
+  end
 end

data/spec/services/middleware/exception_reporting/reporters/airbrake_reporter_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'raygun4ruby'
+require 'airbrake'
 
 # This doesn't test the Airbrake gem / configuration itself - just check that
 # the appropriate Airbrake method gets called.
@@ -15,10 +15,87 @@ describe Hoodoo::Services::Middleware::ExceptionReporting::AirbrakeReporter do
     Hoodoo::Services::Middleware::ExceptionReporting.remove( described_class )
   end
 
-  it 'calls Airbrake' do
-    Hoodoo::Services::Middleware::ExceptionReporting.add( described_class )
-    ex = RuntimeError.new( 'A' )
-    expect( Airbrake ).to receive( :notify_or_ignore ).once.with( ex, { :rack_env => nil } )
-    Hoodoo::Services::Middleware::ExceptionReporting.report( ex )
+  context '#report' do
+    it 'calls Airbrake correctly without an "env"' do
+      ex = RuntimeError.new( 'A' )
+
+      expect( Airbrake ).to receive( :notify_or_ignore ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to have_key( :backtrace )
+        expect( opts ).to_not have_key( :rack_env )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.report( ex )
+    end
+
+    it 'calls Airbrake correctly with an "env"' do
+      ex       = RuntimeError.new( 'A' )
+      mock_env = { 'rack' => 'request' }
+
+      expect( Airbrake ).to receive( :notify_or_ignore ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to have_key( :backtrace )
+
+        expect( opts[ :rack_env ] ).to eq( mock_env )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.report( ex, mock_env )
+    end
+  end
+
+  context '#contextual_report' do
+    it 'calls Airbrake correctly' do
+      ex             = RuntimeError.new( 'A' )
+      co             = OpenStruct.new
+      mock_user_data = { :foo => :bar }
+      mock_env       = { 'rack' => 'request' }
+
+      co.owning_interaction                  = OpenStruct.new
+      co.owning_interaction.rack_request     = OpenStruct.new
+      co.owning_interaction.rack_request.env = mock_env
+
+      expect( described_class.instance ).to receive( :user_data_for ).once.and_return( mock_user_data )
+
+      expect( Airbrake ).to receive( :notify_or_ignore ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to have_key( :backtrace )
+
+        expect( opts[ :rack_env         ] ).to eq( mock_env )
+        expect( opts[ :environment_name ] ).to eq( 'test' )
+        expect( opts[ :session          ] ).to eq( mock_user_data )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+    end
+
+    it 'has special case handling for user data recovery failure' do
+      ex       = RuntimeError.new( 'A' )
+      co       = OpenStruct.new
+      mock_env = { 'rack' => 'request' }
+
+      co.owning_interaction                  = OpenStruct.new
+      co.owning_interaction.rack_request     = OpenStruct.new
+      co.owning_interaction.rack_request.env = mock_env
+
+      expect( described_class.instance ).to receive( :user_data_for ).once.and_return( nil )
+
+      expect( Airbrake ).to receive( :notify_or_ignore ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to have_key( :backtrace )
+
+        expect( opts[ :rack_env         ] ).to eq( mock_env )
+        expect( opts[ :environment_name ] ).to eq( 'test' )
+        expect( opts[ :session          ] ).to eq( 'unknown' )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+    end
   end
 end

data/spec/services/middleware/exception_reporting/reporters/raygun_reporter_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'airbrake'
+require 'raygun4ruby'
 
 # This doesn't test the Raygun gem / configuration itself - just check that
 # the appropriate Raygun method gets called.
@@ -15,9 +15,75 @@ describe Hoodoo::Services::Middleware::ExceptionReporting::RaygunReporter do
     Hoodoo::Services::Middleware::ExceptionReporting.remove( described_class )
   end
 
-  it 'calls Raygun' do
-    ex = RuntimeError.new( 'A' )
-    expect( Raygun ).to receive( :track_exception ).once.with( ex, nil )
-    Hoodoo::Services::Middleware::ExceptionReporting.report( ex )
+  context '#report' do
+    it 'calls Raygun correctly without an "env"' do
+      ex = RuntimeError.new( 'A' )
+
+      expect( Raygun ).to receive( :track_exception ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+        expect( opts ).to be_nil
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.report( ex )
+    end
+
+    it 'calls Raygun correctly with an "env"' do
+      ex       = RuntimeError.new( 'A' )
+      mock_env = { 'rack' => 'request' }
+
+      expect( Raygun ).to receive( :track_exception ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to eq( mock_env )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.report( ex, mock_env )
+    end
+  end
+
+  context '#contextual_report' do
+    it 'calls Raygun correctly' do
+      ex             = RuntimeError.new( 'A' )
+      co             = OpenStruct.new
+      mock_user_data = { :foo => :bar }
+      mock_env       = { 'rack' => 'request' }
+
+      co.owning_interaction                  = OpenStruct.new
+      co.owning_interaction.rack_request     = OpenStruct.new
+      co.owning_interaction.rack_request.env = mock_env
+
+      expect( described_class.instance ).to receive( :user_data_for ).once.and_return( mock_user_data )
+
+      expect( Raygun ).to receive( :track_exception ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to eq( mock_env.merge( :custom_data => mock_user_data ) )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+    end
+
+    it 'has special case handling for user data recovery failure' do
+      ex       = RuntimeError.new( 'A' )
+      co       = OpenStruct.new
+      mock_env = { 'rack' => 'request' }
+
+      co.owning_interaction                  = OpenStruct.new
+      co.owning_interaction.rack_request     = OpenStruct.new
+      co.owning_interaction.rack_request.env = mock_env
+
+      expect( described_class.instance ).to receive( :user_data_for ).once.and_return( nil )
+
+      expect( Raygun ).to receive( :track_exception ).once do | e, opts |
+        expect( e ).to be_a( Exception )
+
+        expect( opts ).to be_a( Hash )
+        expect( opts ).to eq( mock_env.merge( :custom_data => { 'user_data' => 'unknown' } ) )
+      end
+
+      Hoodoo::Services::Middleware::ExceptionReporting.contextual_report( ex, co )
+    end
   end
 end

data/spec/services/middleware/middleware_spec.rb

@@ -367,7 +367,7 @@ describe Hoodoo::Services::Middleware do
 
       expect(Hoodoo::Services::Middleware.environment).to receive(:test?).once.and_return(false)
       expect(Hoodoo::Services::Middleware.environment).to receive(:development?).and_return(false)
-      expect(Hoodoo::Services::Middleware::ExceptionReporting).to receive(:report).and_raise("boo!")
+      expect(Hoodoo::Services::Middleware::ExceptionReporting).to receive(:contextual_report).and_raise("boo!")
 
       # Route through to the unimplemented "list" call, so the subclass raises
       # an exception. This is tested independently elsewhere too. This causes
@@ -381,6 +381,28 @@ describe Hoodoo::Services::Middleware do
       expect(last_response.body).to eq('Middleware exception in exception handler')
     end
 
+    it 'a matching endpoint should fall back to the basic reporting API if context is not available' do
+
+      # See previous test for details.
+
+      expect(Hoodoo::Services::Middleware.environment).to receive(:test?).once.and_return(true)
+      expect(Hoodoo::Services::Middleware.environment).to receive(:test?).once.and_return(false)
+      expect(Hoodoo::Services::Middleware.environment).to receive(:development?).and_return(false)
+
+      expect(Hoodoo::Services::Middleware::Interaction).to receive(:new) do
+        raise("boo!")
+      end
+
+      # All we care about is seeing a call to #report instead of
+      # #contextual_report as in the previous test. Things will probably
+      # fail and fall to the fallback handler eventually anyway given that
+      # we broke the attempt to create an Interaction instance deliberately,
+      # so don't worry about examining the 'get' results.
+      #
+      expect(Hoodoo::Services::Middleware::ExceptionReporting).to receive(:report)
+      get '/v2/rspec_test_service_stub', nil, { 'CONTENT_TYPE' => 'application/json; charset=utf-8' }
+    end
+
     # -------------------------------------------------------------------------
 
     describe 'service implementation #before and #after' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-16 00:00:00.000000000 Z
+date: 2016-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio