fix(rails): ensure Rails.error.set_context is not lost

sentry-rails/lib/sentry/rails/active_job.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "set"
+require "sentry/rails/error_reporter_context"
+require "sentry/rails/structure_sanitizer"
 
 module Sentry
   module Rails
@@ -193,6 +195,7 @@ def capture_exception(job, e)
                 job_id: job.job_id,
                 provider_job_id: job.provider_job_id
               },
+              contexts: ErrorReporterContext.contexts,
               # Send synchronously: a worker process may exit before the async
               # background worker flushes its queue, which would drop the event.
               hint: { background: false }
@@ -248,22 +251,7 @@ def sentry_context(job)
           end
 
           def sentry_serialize_arguments(argument)
-            case argument
-            when Range
-              if (argument.begin || argument.end).is_a?(ActiveSupport::TimeWithZone)
-                argument.to_s
-              else
-                argument.map { |v| sentry_serialize_arguments(v) }
-              end
-            when Hash
-              argument.transform_values { |v| sentry_serialize_arguments(v) }
-            when Array, Enumerable
-              argument.map { |v| sentry_serialize_arguments(v) }
-            when ->(v) { v.respond_to?(:to_global_id) }
-              argument.to_global_id.to_s rescue argument
-            else
-              argument
-            end
+            Sentry::Rails::StructureSanitizer.sanitize(argument)
           end
 
           private

sentry-rails/lib/sentry/rails/capture_exceptions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "sentry/rails/error_reporter_context"
+
 module Sentry
   module Rails
     class CaptureExceptions < Sentry::Rack::CaptureExceptions
@@ -30,7 +32,7 @@ def capture_exception(exception, env)
         return unless Sentry.initialized?
         return if show_exceptions?(exception, env) && !Sentry.configuration.rails.report_rescued_exceptions
 
-        Sentry::Rails.capture_exception(exception).tap do |event|
+        Sentry::Rails.capture_exception(exception, contexts: ErrorReporterContext.contexts).tap do |event|
           env[ERROR_EVENT_ID_KEY] = event.event_id if event
         end
       end

sentry-rails/lib/sentry/rails/error_reporter_context.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "sentry/rails/structure_sanitizer"
+
+module Sentry
+  module Rails
+    module ErrorReporterContext
+      SUPPORTS_EXECUTION_CONTEXT = Gem::Version.new(::Rails.version) >= Gem::Version.new("7.0.0")
+
+      PRIMITIVE_CLASSES = [String, Numeric, Symbol, NilClass, TrueClass, FalseClass].freeze
+
+      class << self
+        if SUPPORTS_EXECUTION_CONTEXT
+          def contexts
+            execution_context = ::ActiveSupport::ExecutionContext.to_h
+            return {} if execution_context.empty?
+
+            sanitized = Sentry::Rails::StructureSanitizer.sanitize(execution_context) do |leaf|
+              PRIMITIVE_CLASSES.any? { |klass| leaf.is_a?(klass) } ? leaf : leaf.class.name
+            end
+
+            { "rails.error" => sanitized }
+          end
+        else
+          def contexts
+            {}
+          end
+        end
+      end
+    end
+  end
+end

sentry-rails/lib/sentry/rails/structure_sanitizer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Rails
+    module StructureSanitizer
+      def self.sanitize(value, &leaf)
+        case value
+        when Range
+          sanitize_range(value, &leaf)
+        when Hash
+          value.transform_values { |v| sanitize(v, &leaf) }
+        when Array, Enumerable
+          value.map { |v| sanitize(v, &leaf) }
+        when ->(v) { v.respond_to?(:to_global_id) }
+          begin
+            value.to_global_id.to_s
+          rescue StandardError
+            leaf ? leaf.call(value) : value
+          end
+        else
+          leaf ? leaf.call(value) : value
+        end
+      end
+
+      def self.sanitize_range(range, &leaf)
+        boundary = range.begin || range.end
+
+        if boundary.is_a?(::ActiveSupport::TimeWithZone)
+          range.to_s
+        else
+          range.map { |v| sanitize(v, &leaf) }
+        end
+      end
+    end
+  end
+end

sentry-rails/spec/active_job/shared_examples/error_context.rb

@@ -36,4 +36,22 @@ def perform
     last_frame = event.exception.values.first.stacktrace.frames.last
     expect(last_frame.vars).to include(a: "1", b: "0")
   end
+
+  it "includes Rails.error.set_context data attached before the job raises", skip: RAILS_VERSION < 7.0 do
+    job_with_context = job_fixture do
+      def perform
+        Rails.error.set_context(debug_key: "important_value")
+        raise "boom with rails error context"
+      end
+    end
+
+    expect do
+      job_with_context.perform_later
+      drain
+    end.to raise_error(RuntimeError, /boom with rails error context/)
+
+    event = last_sentry_event
+
+    expect(event.contexts).to include("rails.error" => hash_including(debug_key: "important_value"))
+  end
 end

sentry-rails/spec/dummy/test_rails_app/app/controllers/hello_controller.rb

@@ -7,6 +7,11 @@ def exception
     raise "An unhandled exception!"
   end
 
+  def exception_with_error_context
+    Rails.error.set_context(debug_key: "important_value")
+    raise "An unhandled exception with Rails.error context!"
+  end
+
   def reporting
     render plain: Sentry.last_event_id
   end

sentry-rails/spec/dummy/test_rails_app/config/application.rb

@@ -122,6 +122,7 @@ def configure
 
           routes.append do
             get "/exception", to: "hello#exception"
+            get "/exception_with_error_context", to: "hello#exception_with_error_context"
             get "/view_exception", to: "hello#view_exception"
             get "/view", to: "hello#view"
             get "/not_found", to: "hello#not_found"

sentry-rails/spec/sentry/rails/structure_sanitizer_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Sentry::Rails::StructureSanitizer do
+  describe ".sanitize" do
+    it "yields primitive values to the leaf block" do
+      result = described_class.sanitize("foo") { |leaf| leaf.upcase }
+
+      expect(result).to eq("FOO")
+    end
+
+    it "recursively sanitizes hash values" do
+      result = described_class.sanitize({ a: 1, b: { c: 2 } }) { |leaf| leaf * 10 }
+
+      expect(result).to eq(a: 10, b: { c: 20 })
+    end
+
+    it "recursively sanitizes array elements" do
+      result = described_class.sanitize([1, [2, 3]]) { |leaf| leaf * 10 }
+
+      expect(result).to eq([10, [20, 30]])
+    end
+
+    it "expands ranges into arrays" do
+      result = described_class.sanitize(1..3) { |leaf| leaf }
+
+      expect(result).to eq([1, 2, 3])
+    end
+
+    context "when the range boundary is an ActiveSupport::TimeWithZone" do
+      it "stringifies the range instead of expanding it" do
+        zone = ActiveSupport::TimeZone["UTC"]
+        range = (zone.now - 1.day)...zone.now
+
+        result = described_class.sanitize(range) { |leaf| leaf }
+
+        expect(result).to eq(range.to_s)
+      end
+    end
+
+    context "when the value responds to to_global_id" do
+      it "resolves it to its global id string" do
+        object = double("GlobalID-aware", to_global_id: double(to_s: "gid://app/Foo/1"))
+
+        result = described_class.sanitize(object) { |leaf| leaf.class.name }
+
+        expect(result).to eq("gid://app/Foo/1")
+      end
+
+      it "falls back to the leaf block when to_global_id raises" do
+        object = double("GlobalID-aware")
+        allow(object).to receive(:to_global_id).and_raise("intentional")
+
+        result = described_class.sanitize(object) { |leaf| leaf.class.name }
+
+        expect(result).to eq(object.class.name)
+      end
+    end
+
+    it "yields plain objects that don't match any structural case to the leaf block" do
+      object = Object.new
+
+      result = described_class.sanitize(object) { |leaf| leaf.class.name }
+
+      expect(result).to eq("Object")
+    end
+
+    context "without a leaf block" do
+      it "returns plain objects unchanged" do
+        object = Object.new
+
+        expect(described_class.sanitize(object)).to equal(object)
+      end
+
+      it "returns objects unchanged when to_global_id raises" do
+        object = double("GlobalID-aware")
+        allow(object).to receive(:to_global_id).and_raise("intentional")
+
+        expect(described_class.sanitize(object)).to equal(object)
+      end
+    end
+  end
+end

sentry-rails/spec/sentry/rails_spec.rb

@@ -373,6 +373,15 @@ def capture_in_separate_process(exit_code:)
 
         expect(transport.events.count).to eq(0)
       end
+
+      it "includes Rails.error.set_context data attached before an unhandled request exception" do
+        get "/exception_with_error_context"
+
+        expect(transport.events.count).to eq(1)
+
+        event = transport.events.first
+        expect(event.contexts).to include("rails.error" => hash_including(debug_key: "important_value"))
+      end
     end
   end
 end