Merge pull request rails#54512 from Shopify/error-reporter-metadata-provider

Introduce ActiveSupport::ErrorReport#metadata_provider

Author: byroot

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