Introduce ErrorReporter context middleware

Co-authored-by: Sam Schmidt <[email protected]>

When reporting an error, the error context middleware will be called
with the reported error and base execution context. The stack may mutate
the context hash. The mutated context will then be passed to error
subscribers.

Author: andrewn617

activesupport/CHANGELOG.md

@@ -1,3 +1,11 @@
+*   Introduce ActiveSupport::ErrorReporter#add_middleware
+
+    When reporting an error, the error context middleware will be called with the reported error
+    and base execution context. The stack may mutate the context hash. The mutated context will
+    then be passed to error subscribers.
+
+    *Andrew Novoselac*, *Sam Schmidt*
+
 *   Change execution wrapping to report all exceptions, including `Exception`.
 
     If a more serious error like `SystemStackError` or `NoMemoryError` happens,

activesupport/lib/active_support/error_reporter.rb

@@ -36,6 +36,7 @@ def initialize(*subscribers, logger: nil)
       @subscribers = subscribers.flatten
       @logger = logger
       @debug_mode = false
+      @context_middlewares = ErrorContextMiddlewareStack.new
     end
 
     # Evaluates the given block, reporting and swallowing any unhandled error.
@@ -202,6 +203,22 @@ def set_context(...)
       ActiveSupport::ExecutionContext.set(...)
     end
 
+    # Add a middleware to modify the error context before it is sent to subscribers.
+    #
+    # Middleware is added to a stack of callables run on an error's execution context
+    # before passing to subscribers. Allows creation of entries in error context that
+    # are shared by all subscribers.
+    #
+    # A context middleware receives the error and current state of the context hash.
+    # It must return a hash - the middleware stack returns the hash after it has
+    # run through all middlewares. A middleware can mutate or replace the hash.
+    #
+    #   Rails.error.add_middleware(-> (error, context) { context.merge({ foo: :bar }) })
+    #
+    def add_middleware(middleware)
+      @context_middlewares.use(middleware)
+    end
+
     # Report an error directly to subscribers. You can use this method when the
     # block-based #handle and #record methods are not suitable.
     #
@@ -223,7 +240,11 @@ def report(error, handled: true, severity: handled ? :warning : :error, context:
         raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
       end
 
-      full_context = ActiveSupport::ExecutionContext.to_h.merge(context || {})
+      full_context = @context_middlewares.execute(
+        error,
+        ActiveSupport::ExecutionContext.to_h.merge(context || {})
+      )
+
       disabled_subscribers = ActiveSupport::IsolatedExecutionState[self]
       @subscribers.each do |subscriber|
         unless disabled_subscribers&.any? { |s| s === subscriber }
@@ -272,5 +293,25 @@ def ensure_backtrace(error)
 
         error.backtrace.shift(count)
       end
+
+      class ErrorContextMiddlewareStack # :nodoc:
+        def initialize
+          @stack = []
+        end
+
+        # Add a middleware to the error context stack.
+        def use(middleware)
+          unless middleware.respond_to?(:call)
+            raise ArgumentError, "Error context middleware must respond to #call"
+          end
+
+          @stack << middleware
+        end
+
+        # Run all middlewares in the stack on an error and context.
+        def execute(error, context)
+          @stack.inject(context) { |c, middleware| middleware.call(error, c) }
+        end
+      end
   end
 end

activesupport/test/error_reporter_test.rb

@@ -362,4 +362,40 @@ def report(_error, handled:, severity:, context:, source:)
     expected = "Error subscriber raised an error: Big Oopsie (ErrorReporterTest::FailingErrorSubscriber::Error)"
     assert_equal expected, log.string.lines.first.chomp
   end
+
+  test "error context middleware can mutate context hash" do
+    middleware = -> (_, context) { context.merge({ foo: :bar }) }
+
+    error = ArgumentError.new("Oops")
+
+    @reporter.add_middleware(middleware)
+    @reporter.report(error)
+
+    assert_equal [[error, true, :warning, "application", { foo: :bar }]], @subscriber.events
+  end
+
+  class MyErrorContextMiddleware
+    def call(_, context)
+      context.merge({ bar: :baz })
+    end
+  end
+
+  test "can have multiple error context middlewares" do
+    @reporter.add_middleware(-> (_, context) { context.merge({ foo: :bar }) })
+    @reporter.add_middleware(MyErrorContextMiddleware.new)
+
+    error = ArgumentError.new("Oops")
+    @reporter.report(error)
+
+    assert_equal [[error, true, :warning, "application", { foo: :bar, bar: :baz }]], @subscriber.events
+  end
+
+  test "last error context middleware to update a key wins" do
+    @reporter.add_middleware(-> (_, context) { context.merge({ foo: :bar }) })
+    @reporter.add_middleware(-> (_, context) { context.merge({ foo: :baz }) })
+    error = ArgumentError.new("Oops")
+    @reporter.report(error)
+
+    assert_equal [[error, true, :warning, "application", { foo: :baz }]], @subscriber.events
+  end
 end